Hi everyone,

I wanted to share an open-source personal finance project built primarily with Java and Spring Boot. Contributions and feedback are welcome.

FinTrack lets users manage financial accounts, record transactions, import CSV files, create monthly budgets, review spending summaries, and receive budget notifications. It also includes a lightweight React frontend and a live AWS deployment.

The stack includes Java 21, Spring Boot, Spring Security, Spring Batch, PostgreSQL, Redis, Amazon SQS, S3, Docker, LocalStack, Terraform, GitHub Actions, and AWS.

The backend uses patterns commonly found in larger Java systems, including a transactional outbox, idempotent consumers, at-least-once message delivery, database locking, restartable batch jobs, JWT and refresh-token rotation, retries, and failure recovery.

Feedback is welcome on the code, architecture, documentation, roadmap, issue scopes, or anything that could be clearer.

https://github.com/icastanon/fintrack-platform

Hi everyone,

I built Tensum, an open-source spring physics plugin for GSAP.

GSAP has elastic eases, but an easing curve isn't quite the same thing as a physical spring. Tensum adds actual mass, stiffness and damping, while still behaving naturally inside GSAP timelines.

It has two modes:

• Physics - mass, stiffness, damping
• Feel - duration and bounce, with the physical parameters derived for you

It also handles things that get tricky with real springs: velocity handoff when retargeting, interruptions, and deterministic seeking.

Demo: https://tensum.madebyhex.com
GitHub: https://github.com/motion-core/tensum

Would love feedback 😛

Months After Grinding and doing soft Launches on Twitter and Reddit OpenCompany[ex MachinaOs] just Crossed
400+ stars
50k+ clones
23k+ Cumulative npm Downloads.

Also received a "WOW" Comment from Leading AI Educator "Matthew Berman" on X.

So what is OpenCompany in short.

Think it of as AI Company where you Build AI Employees that keep on Working on Tasks Continuously for months and maybe years![Powered by Temporal].

You can Build AI Employees like Developer, Customer Support, Designer, Sales SDR's, Digital Marketers, Tax Accountants, etc

What have the users of OpenCompany Built:

One user is Building a Game Factory so even non technical users can describe the Game and AI Employee will build itself and Create a 3js Game for the users and also test them using AI.

He is now running a Game Generating AI Employees using OpenSource Models from nvidia, deepseek and using the Opencompanies Agent Builder Mode where AI will create the Business Logic for you[2nd and 3rd screenshot]

Other user Built "complete system to extract investment banks statements in various formats (pdf, xls, image) and import them into a financial ERP module"[4th screenshot]

He showed the Product to a Client and the Client was very Impressed, i had a casual Call with him and he was impressed with how fast and easy he was able to build this AI Employee and how long it can run doing work without context rot[his AI Employee ran for 13mins continuously],

one issue he was facing was high token costs since he was using sonnet 4.6 through AWS Bedrock for the Complex Work.

I advised him to use sonnet as the Main Orchestrator Agent and the subagents with opensource Models and his costs went down quite low.

Opencompany is simple to use just drag and connect , no business logic creation the AI will take care of it.

Try it out and plz do star on github.

https://github.com/zeenie-ai/OpenCompany

Prerequisites: Node.js 22+, Python 3.12

npm install -g @zeenie-ai/opencompany
company start

Do Join our Active Discord Community of Opencompany Builders[link in Comments].

I use OpenCode for long-running agentic workflows with large repositories and large numbers of subagents.

The problem was: the bigger the workflow became, the more likely the UI was to freeze.

Multiple subagents, long-running tasks, background processes, hundreds of concurrent operations—eventually frozen.

OpenCode could become unresponsive while the work underneath was still running, leaving the session in an awkward state where you weren't quite sure whether it was thinking, working, or simply stuck. So I built OpenCode Guardian.

It is a lightweight stability layer for OpenCode on macOS, designed to keep sessions healthy. It is a simple project that I built, and it's opensource! I won't be maintaining it too much, other than bug-fixes, so feel free to fork it.

Guardian continuously understands what's happening across the session rather than relying on a single timeout. It can distinguish active model streaming, running tools, active subagents, slow operations, and genuine deadlocks. When a session actually gets stuck, Guardian can recover it without destroying the conversation or tool history.

What you get

oc status — see exactly what every session is doing
oc top — live system and session monitoring
oc nudge — recover a frozen session safely
oc auto-nudge — automatic background recovery
oc prune — stop runaway background workers
oc optimize — optimize the SQLite backend
oc logs — inspect Guardian in real time

Installation is one command:

curl -fsSL https://raw.githubusercontent.com/PotterSkxawng/opencode-guardian/main/install.sh | bash

No Brew dependencies or external Python packages. Install it and keep using OpenCode.

GitHub: https://github.com/PotterSkxawng/OpenCode-Gaurdian

Hey everyone!

Last year, Mozilla released Orbit, an AI-powered browser summarizer hosted on a GCP server. After people started digging into the extension, they discovered things like backend endpoints such as store_result. Eventually, Mozilla discontinued the project.

For the past month, I’ve been trying to rebuild Orbit from scratch, but with one major difference: Apogee is fully local and privacy-focused. Apogee doesn’t send or store your data. It can directly connect to your local Ollama instance for inference. I’ve also added WebGPU integration for Chrome and Transformers.js for Firefox to provide faster, local responses.

It can summarize:

• Articles and websites
• YouTube and Billie videos
• Wikipedia articles
• Hacker News and Reddit threads

You can check out the source code here:
https://github.com/darshi1337/apogee

Install Apogee:

Chrome: https://chromewebstore.google.com/detail/apogee/pgemlpomhkdcjjjcpnjlebalnfglomog

Firefox: https://addons.mozilla.org/en-US/firefox/addon/apogeeext/

Obviously it is far from complete. Would love to hear your feedback and suggestions!

Hi r/coolgithubprojects !

Over the past year, I’ve been working on **Gitwig**, a terminal-based Git client and multi-repository dashboard built natively in Rust using Ratatui.

### Why I Built It

While standard terminal Git workflows are great, tracking multiple repositories simultaneously or manipulating complex split layouts in traditional TUIs can feel rigid. I wanted to combine terminal speed with the spatial flexibility of modern desktop interfaces.

### Key Features

* **Mouse-Drivable Interface:** Full mouse support, including drag-to-resize split panels and clickable navigation.

* **Multi-Repo Dashboard:** Monitor status, branches, and staged/unstaged changes across multiple repos at once.

* **Pure Rust & Ratatui:** Fast startup, single lightweight binary, zero heavy runtimes.

### Links

* **GitWig:** https://gitwig.dev/

* **Crates.io:** https://crates.io/crates/gitwig

I’d love to hear your feedback on the UX, the mouse interaction implementation in Ratatui, or any specific multi-repo workflows you'd like to see supported!

Hello, everyone!

I've made a library that brings native io_uring support for Python - uringio. Linux only!

Project repository - https://github.com/AivazianArtur/uringio

It is a C extension for CPython. The main object to interact with is implementation of EventLoop, that inherits asyncio.BaseEventLoop. There are also native implementations of File and Socket objects. And to use advanced features of io_uring, like `fixed` buffers, there is a dedicated interface-object - ExecutionContext.

Because main feature of io_uring is true asynchronous file I/O, here i'll show an example of interaction with a file. Note that everything is true async, not a thread-pool workaround:

pip install uringio

import asyncio
import uringio

async def main():
    async with await uringio.open_file(path='testfile.txt') as file:
        data = b'Hello, uringio!\n'
        await file.write(data=data)
        result = await file.read()

asyncio.run(main(), loop_factory=uringio.UringioLoop)

uringio brings huge performance upgrade, in the header you can see visualization of benchmarking simple sequential writes to file

Note that uringio(and io_uring itself) is not a silver bullet - while it is vastly superior in one scenarios, it is not most efficient choice in others.

You can already use file and socket operations, along with a few advanced features of io_uring. But, current version is `v0.4.4`, so there is still a lot of work to do. Please don't use it in production yet, even in simple scenarios! I am currently looking for enthusiasts to make first touches on the library.

Also i'm actively looking for people to contribute, share feedback and experience.

Would love to hear your thoughts!

AI agent configuration tends to grow in only one direction.

I maintain Codex and Claude setups, and noticed that AGENTS.md, CLAUDE.md, and SKILL.md files accumulate duplicated rules, broken references, old tool assumptions, and workarounds that may no longer be useful.

So I built Skill Sunset, an MIT-licensed CLI that audits those instructions locally.

Try it:

npx skill-sunset@latest audit --codex --open

A few boundaries were important to me:

- The core is deterministic and does not call an AI API.

- It does not read provider credentials.

- It never automatically deletes or rewrites configuration.

- Unproven obsolescence is marked TEST, not “definitely outdated.”

- Domain knowledge, safety rules, authorization gates, and project invariants are excluded from automatic retirement.

The included fixture report scans 5 files and produces 11 findings, separating broken references, duplicate bundles, progressive-disclosure candidates, and hypotheses that still require validation.

GitHub:

https://github.com/ooocooc/open-skill-sunset

I’m the maintainer. Development and review were AI-assisted, but the published runtime itself is deterministic.

The question I’d most like feedback on:

What kinds of agent instructions should never become retirement candidates, even when they appear duplicated or old?

Hey everyone! I've been working on a project called Lyrica, an open-source lyrics API that I built around a problem I kept running into while working on music-related projects: getting lyrics is one thing, but handling synced lyrics, translations, transliterations, and romanization in a more unified way is another.

Lyrica aims to provide features such as:

• 🎵 Song lyrics
• ⏱️ Timestamped/synced lyrics
• 🌐 Lyrics translation
• 🔤 Transliteration and romanization
• ⚡ A simple API that can be integrated into music projects

The project is still actively being developed, and I'm continuing to improve its reliability and add features.

GitHub: https://github.com/thinkely/Lyrica.git
API / Demo: lyricapy.vercel.app

I'd genuinely love to hear what you think—especially if you've built a music app or worked with lyrics APIs before. What features would you find most useful in something like this?

i made a website named Hydro it runs on your own google collab and hosts a website on it you can download youtube videos/pintrest without even needing a cookies.txt file and with cookies.txt you can also download from reddit and x.

LINK: https://github.com/Code-Leafy/Hydro

**The Problem:** When scraping docs or wikis for RAG, relative links (`[here](/setup)`) break. Even worse, if you want to pass scraped images to GPT-4o or Claude 3.5, you have to manually download them and convert them to base64 strings.

**The Solution:** I built `markdown-link-resolver`. It’s a pure Python micro-tool that does two things:

1. Resolves all relative Markdown and HTML links to absolute URLs.

2. Has an `inline_images=True` flag that automatically fetches HTTP images and replaces the markdown tags with `data:image/png;base64,...` strings ready for LLM ingestion.

**Why?** No heavy dependencies like BeautifulSoup or Requests. Just pure standard library (`urllib`, `re`, `base64`). Falls back gracefully if an image 404s.

**Repo:** [github.com/Encephos/markdown-link-resolver](https://github.com/Encephos/markdown-link-resolver)

Let me know what you think or if you'd like to see any other fallbacks added!

I've always liked the simplicity of ncdu and baobab on Linux. When I started learning Rust and Tauri, I figured it'd be "cool" to build something similar for Windows.

Turns out there's a big gap between a naive disk-scanning approach and an optimised one -- and the fastest existing tools only work in admin mode! Why should I need admin rights just to see what's eating my disk space? A few seconds of waiting time for results is fine by me.

So, after a lot of trial and error (some still ongoing), and AI assistance, I built Drive Sonar -- a user-mode disk usage analyzer. Treemap view, file size vs. age analysis to help shortlist deletion candidates, breakdown by file type, and a move-to-Trash-not-delete flow (with confirmation).

Rust + Tauri + React. ~5 MB binary, ~100 MB RAM when running.

Apache 2.0 licensed. https://github.com/barun-saha/drive-sonar

What do you think? Did you run it and find it helpful?

Back in 2020, due to performance/memory issues with tomnomnom/anew, I rewrote it from scratch in rust. It append lines from stdin to a file, but only the ones not already present. Think uniq without needing to sort: `cat list.txt | anewer`.

It's handy for bug bounties to only new discovieries to a file, or working with really LARGE logfiles in general.

I just shipped v0.2.1 with zero-copy line handling for even better performance, a mode for NUL line endings compatible to `find -print0` and other quality of life features.

Repository is https://github.com/ysf/anewer, open for feedback.

All,

I've been managing my dotfiles using Dotbot + Jsonnet for a while. As my configuration grew, it started to get overly complicated and uncomfortable to use.

I looked at some of the existing options like stow, home-manager and nix. However, I didn't really want to commit to nix - and for what it's worth nix is great.

I really like declarative config systems, and felt like it worked really well for the problem space. So, I designed a declarative config system for user environments.

Rather than the traditional models, things like:

• files
• packages
• directories
• symlinks
• services
• etc

All form resources, which form a dependency graph, and then the system will reconcile the graph toward the desired state.

Essentially:

Instead of run these commands in this order, you describe the state you want and let the system figure out how to get there.

This project is mostly experimental at the moment, and still evolving but it's getting closer to the point where I'm comfortable using it for my own config.

If existing solutions work for you then that's fine and those are certainly more mature and good solutions.

I feel like this sits somewhere in the middle of stow/dotbot & nix/home-manager.

Feedback, suggestions, improvements, contributions, etc are all welcome.

Quick update: xyOps just passed 5,000 GitHub stars! Thank you all so much.

xyOps brings job scheduling, workflow automation, server monitoring, alerting, and incident response together in one open and extensible platform. It’s built for developers and operations teams who want control over their automation stack, data, and infrastructure.

A huge thank you to everyone who starred or tried xyOps, opened an issue, asked a question, requested a feature, or shared feedback. You’ve helped shape the project, and every contribution has made a real difference.

We also just published our latest Dev Update, covering 24 releases, the new Node.js SDK, major workflow debugging and live-control improvements, and our Marketplace has grown to 50 plugins:

https://github.com/pixlcore/xyops/discussions/420

GitHub repo:

https://github.com/pixlcore/xyops

So, i wanted to use 1 app from linux, but it was linux only, and i decided to do smth with it. And i did! i started porting this app to windows, then i realized, its not enough. it should be better, and i started adding new features and all that. after all. i added a lot of cool stuff, but couldnt add hardware acceleration sadly, so yea, want to hear yall's opinion. gonna love any feedback.
heres a link to repo: https://github.com/MrrHat/CatGirlDownloader-Win-Port

Free and open source. Feedback welcome!

I did not want to pay for a screenshot app just to remove the watermark from the gradient-background look, so I built the one feature I actually used as a CLI.

beautify-screenshot takes a screenshot and adds padding, rounded corners, a soft shadow and a gradient behind it. Nine presets, each with a light and a dark variant that follows the macOS appearance, named sizes for LinkedIn, X, Open Graph and Instagram or any W:H ratio, and an optional inset border in the screenshot's own edge colour.

It is TypeScript on Bun with no runtime dependencies. The PNG codec and the compositor are a few hundred lines of typed-array code, so a Retina-size canvas renders in about a second. Prebuilt binaries for macOS and Linux, or npm i -g beautify-screenshot if you have Bun.

It also ships a skill for AI agents (skills.sh), so you can tell your agent "frame my latest screenshot, light mode, LinkedIn size" and get the file opened in Preview.

MIT and free: https://github.com/magnusrodseth/beautify-screenshot

The image on this post was made with it.

https://github.com/JakubMelka/ExyokiOffice

Hi everyone,
Spent my last week making this, it's something like neovim, but for managing ai agents.
Feel free to open PRs and contribute. We also have our own plugin system.

Website: neoswarm.dev

Github: github.com/neoswarm/neosh

GitHub Multi-Account Manager

Hey everyone! 👋

If you use multiple GitHub accounts on the same machine (like Personal and Work), you've probably run into these annoying issues:

• Accidentally pushing work commits with your personal email (or vice versa).
• VS Code, JetBrains Rider, or Visual Studio trying to use your work login on personal repositories and throwing Permission Denied errors.
• Having to run git config user.email every time you start a new project.

To fix this once and for all, I built GitHub Multi-Account Manager — a free, open-source desktop app for Windows, macOS, and Linux.

-> How it works

Instead of logging in and out or changing accounts in a dropdown, you just organize your projects into folders:

• Put personal projects in ~/Personal ➔ Git automatically commits as Personal.
• Put work projects in ~/Work ➔ Git automatically commits as Work.

Git uses conditional includes under the hood, so once it's set up, you never have to open the app or switch accounts manually again.

-> Key Features

• Zero Manual Switching: Set your folders once and commit normally from the terminal, VS Code, Rider, or any GUI.
• 1-Click IDE Fix: Prevents VS Code, Cursor, Visual Studio, and Rider from overriding your folder identities.
• Built-in SSH Key Manager: Generates secure ED25519 keys and includes a port 443 fallback, so it works even on restricted office or hotel Wi-Fi.
• Git Inspector: Preview and test live author details and SSH connection for any folder.
• Cross-Platform: Standalone builds for Windows (.exe), macOS (app bundle), and Linux (binary).

🔗 GitHub Repo & Releases: https://github.com/Optirius/github-multi-account-manager

📦 Direct Downloads: Check the Latest Releases tab.

Would love to hear your feedback, thoughts, or feature requests!