r/coolgithubprojects

I've been building an open-source agent (Apache-2.0) and wanted to share it here because it's designed to be fully local and self-hostable: it talks to any OpenAI-compatible endpoint, so Ollama / llama.cpp / vLLM / LM Studio all work as the backend. No cloud lock-in, your keys and data stay yours.

The core idea is LLM-Fusion: for the hard steps it can run a panel of models on the same prompt, have a judge model cross-check them (consensus / contradictions / blind spots), and a synthesizer write the final answer. Locally this is fun because you can mix a few small local models and let them cross-check each other. A cost/latency-aware router keeps easy turns on a single model so you're not paying panel latency for everything.

Beyond that it's a full agent: plan -> act -> verify-or-revert (it runs your tests and treats the result as ground truth), layered memory (SQLite + FTS recall, cross-session profile, consolidation), a governance kernel, cron/proactive jobs, MCP client + OpenAPI-to-tool import, and an isolated subagent/crew layer (parallel git worktrees with per-worker verify gates). Runs on a laptop or a $5 VPS via Docker.

Honest status: it's alpha - 463 tests, mypy --strict clean, but no production mileage yet. Local reasoning quality obviously depends on the models you point it at, so I'd genuinely love to hear which local models people find good enough to actually drive an agent loop (reliable tool use + self-correction) - that's the make-or-break for going fully local.

Repo: https://github.com/brcampidelli/chimera-agent

Every AI trading tool I tried had the same disease: ask it twice, get two different opinions. So I built the opposite - w-bonkers, a deterministic plan-refresh engine for Claude Code (works on Codex too). Same state + same pinned inputs + same rules = same output, every run.

• state.json is the single source of truth. The agent edits state; a Python script deterministically renders the action board, tasks, calendar, and Todoist payload. Views are never hand-edited.
• Todoist is the feedback bus. I comment "bought at 332" → next run records the fill, replies "✓ applied", never re-processes it. Ticking a BUY task means filled on the exchange, not "placed".
• Live broker data via Groww MCP, yfinance fallback. Prices are never invented.
• Deterministic rules: stop/trend/news exits, a regime gate that defers all new buys under the 200-DMA (backtested — harness is in the repo), and portfolio brakes (open-risk cap, weekly loss budget, a circuit breaker that files a p1 task instead of panic-selling).
• Every run archived to disk — fully auditable offline.

The agent never places a trade. It installs itself: clone, open Claude Code, say "read prompt.md" and it interviews you to build your plan.

Repo (MIT): https://github.com/Somchandra17/w-bonkers - educational tooling, not investment advice.

Hey everyone,

I just open-sourced TuneForge.

The goal is simple: let your coding agent manage the full LLM improvement loop without ever leaving the chat window.

You can now tell your agent something like:

“Build me a customer support bot from this FAQ”

…and it can:

• Generate a clean synthetic instruction dataset (with LLM judging for quality)

• Run LoRA supervised fine-tuning on any Hugging Face causal LM

• Do a quick policy-gradient RL step using Ollama as the reward judge

• Merge the adapter, evaluate on a test set, and iterate

Everything runs locally, uses 4-bit quantization so it fits on modest hardware, and uses background jobs (with job_id polling) so long training tasks don’t freeze the MCP connection.

It’s built around the Model Context Protocol (MCP) for seamless integration with Claude Desktop, Cursor, Zed, Continue.dev, etc.

Tech: Python + Transformers + PEFT + bitsandbytes + Ollama + SQLite for job state.

Super early stage (just released), MIT licensed.

Would love feedback or ideas on what to add next. If you’re into agentic fine-tuning workflows, give it a try and let me know how it goes!

I've started this app a while ago, before AI era to create a native client for jellyfin. Back then all clients were either js based(electron) or just targeted one platform.

With this player I covered all platforms within single codebase. I used flutter to build it.

I still build and add new features as of today, over these years got about ~2k active users on ios(dont have data about other platforms)

https://github.com/avdept/JellyBoxPlayer

It's crazy how the community responds when you build something amazing.

This is by far my most useful and succesfull project.
I made a website called letsfg.co where you can get the best flights on the internet. Under the hood it runs hundreds of AI agents on my backend, where each one scans a different website on the internet - Google flights, skyscanner, kayak, kiwi, etc.
It then compares the prices and gives you the best. I explained below why this works.

It's the best thing I've built so far in my 21 years of life, this screenshot shows why:

https://preview.redd.it/48gzmzprwdbh1.png?width=1902&format=png&auto=webp&s=7ef64462f54f6c110f87d29dea090c25a44a72fa

I'll explain below how it works.
And for anybody interested in using there are 3 ways:
- API
- regular website on letsfg.co
- Programmatic flight search (native for OpenClaw and other agents, complex name, but it's basicly an API, the difference is this one uses exactly our website but programmatically, to use this you need to auth by posting a challange code on twitter)

Why this works, and why I made it:
There's a hidden system called GDS where airlines wholesale tickets to websites that buy in bulk like kayak, skyscanner, trip_com, booking, etc. They get the tickets $100-200 cheaper and put their margin/fee on it. The bigger you are the better price you get. These websites compete with each other, so when there is high demand they would lower their own margin on purpose just to be the "best choice". So in short, to get the best price, you need to check the most number of websites.

I made this because I saw my sister-in-law take days of planning, 20 tabs in chrome of multiple websites at once just to make sure she got that flight ticket on the best price. I got reminded that I was guilty of the same thing. I think we love to travel, but we hate what's before the actual trip. Days of planning and stressing, instead of just going.
There is one more thing - I am incredibly obsessed with impacting the world, building a world-known company from Poland and organizing incredible events like Redbull.

I'm incredibly grateful for everybody who shared and continues to share feedback with us to make the service better. Thank you.

Oh, and we're on github: https://github.com/LetsFG/LetsFG

Cheers,
Adam

I got tired of network monitors that look like they were designed for a BBS, so I built flow. It's a real time bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What it does

It shows live download and upload throughput with units that auto scale from B/s up to GB/s. The waveform is a high res Braille grid scrolling at 30fps, and the borders glow brighter as traffic picks up, going from a dark idle state to bright cyan and emerald under load. Numbers are spring interpolated so they glide instead of jumping around. It tracks session peaks, flashing white when you hit a new record, and keeps a running daily total.

There are three views that adapt to your terminal width. Hero is the full dashboard. Compact strips it down to numbers only. Tiny is a single line built for tmux status bars.

Philosophy

If a feature doesn't help you understand your network in under a second, it doesn't make the cut. No CPU panels, no packet counters, no multi pane clutter. Just download and upload throughput, done well.

Usage

flow                        # hero view, auto interface
flow --compact              # numbers only
flow --tiny                 # tmux status bar
flow --json                 # one-shot JSON for scripts
flow --once                 # one-shot plain text

tmux integration

set -g status-right "#(flow --tiny --no-color)"
set -g status-interval 1

Install

go install github.com/programmersd21/flow/cmd/flow@latest

or AUR:

yay -S flow-network-monitor-bin

or homebrew:

brew install programmersd21/flow/flow

Pre-built binaries for Linux, macOS, and Windows (amd64/arm64) are on the releases page.

It works with zero config out of the box. If you want to tweak the refresh rate, history length, or units, there's an optional TOML config at ~/.config/flow/config.toml.

Platform support

It runs on Linux (/proc/net/dev), macOS (sysctl), and Windows (GetIfTable2, no admin needed). Idle CPU stays under 1%.

Links

Source and demo: https://github.com/programmersd21/flow

---

Would love feedback, especially on the tiny/tmux mode. Curious if the info density is right for people running it in a status bar all day.

With the World Cup on, I built a thing that turns any GitHub profile into a FIFA-style player card. You type a username and it scores the profile out of 99 from real data (commits, stars, contributions, PRs, languages) — six stats, a position, a tier from bronze up to ICON, and an archetype like "Poacher" or "Regista" based on your stat shape.

No login or anything. Download the card or embed it in your README.

▎ Try it in: gitfut.com
▎ Github repo : https://github.com/Younesfdj/gitfut

Hi! So Postman was eating 2gb of ram just to send a GET request, and Insomnia was forcing me into an account. Bruno was close to what I wanted, plain YAML files on disk, no account nonsense, but I live in the terminal and wanted something I could use without a mouse, so I built Noodle.

It is a TUI REST client. Requests are .yml files on disk. You browse collections in a sidebar, edit requests inline, swap environments at runtime, send them, and save changes back. No accounts. No telemetry. Just YAML files you can commit to git.

What works:

• Full request lifecycle, browse, edit, send, save
• Create, edit, delete and nest requests on folders
• Inline editing for url, headers, params, body. Keyboard-first, customizable keybindings at ~/.config/noodle/keybinds.yml
• Basic, Bearer, API Key built-in authentication
• Environment switching with $var substitution, cycle environments at runtime without restarting
• Send JSON body, multipart form data, URL-encoded, raw text, binary uploads
• OpenAPI 3.x and Postman importer (CLI only for now, UI is on the list)
• Tab to cycle focus between sidebar, request pane, response pane
• f1 pulls up a keybinding cheatsheet

Not there yet: pre/post scripts, assertions, runner, autocompletion, collection export and other features, but they are all on the roadmap.

Install:

curl -LsSf https://noodlerest.dev/install.sh | sh

Repo: github.com/wilfredinni/noodle

Docs: https://noodlerest.dev/docs/

Roadmap: https://noodlerest.dev/roadmap/

I built this for myself but figured others might want something similar. Feedback is greatly appreciated.

A file format that corrupts itself a little every time you open it. Every open permanently damages the file on disk, by an amount baked into the filename, before it is ever shown to you. There is no recovery from the file alone. The file is the only copy that matters, and every read destroys a little more of it.

The same image, encoded at four instability values and opened in step, decaying at four speeds at once

Two file types:

• .idcy<x> for images (example: photo.idcy3)
• .tdcy<x> for text (example: note.tdcy7)

x is a positive integer in the filename, the instability parameter. Higher x means more corruption per open.

Made this because I had an idea about this weeks ago and it did sound very fun. Kinda analog.

The link to repo - https://github.com/aravpanwar/decayfmt

I spent the last few months building a new sparse fine-tuning method for MoE models called USAF.

The goal was simple: if your GPU can run inference on an MoE model, it should also be able to fine-tune it.

On my AMD RX 6750 XT (12 GB), I can fine-tune Qwen3-30B-A3B by training sparse expert weights and the router instead of adapters.

The project is completely open source under the Apache 2.0 license. I'm not trying to build a business, sell anything, or monetize it in any way—I just wanted to share something I built that I think is genuinely interesting.

GitHub: https://github.com/tsuyu122/usaf

💡 I've just published awesome-commit-conventions (https://github.com/khasky/awesome-commit-conventions), a concise technical reference for commit message conventions.

The guide focuses on writing consistent, readable commit messages that remain useful beyond the initial code change. A well-structured commit history can support code review, debugging, changelog generation, release notes, and versioning decisions.

The reference covers:

- Commit message structure
- Conventional Commits
- Commit types and scopes
- Breaking changes
- SemVer-oriented release workflows
- Changelog-friendly Git history
- Practical examples and common edge cases

GitHub: https://github.com/khasky/awesome-commit-conventions

#Git #ConventionalCommits #SemVer #Changelog #AwesomeLists

Most GitHub profiles don't really tell what an engineer is actually good at.

2 people can have almost same contribution graph, stars and repos.

But one spends years building AI.

Another spends years building dev tools.

You can't really tell from the profile.

So i made something.

Just add "shift" before any GitHub profile URL and it generates a report based on what they've actually built.

Been testing it on random profiles and its pretty interesting 😅

Try yours:

shiftgithub.com/github_username

Curious how accurate it is.

If you like your report, post it on X or LinkedIn. Let people see what you actually build 

EnvTunnel - a free, local-first desktop app that scans for active dev servers and generates instant QR codes using your real local network IP.

EnvTunnel sits in your system tray, scans 16+ dev ports every 3 seconds, and generates a big QR code the moment it detects an active server. Scan it. Open it. Done.

No cloud, no accounts, no internet required. It just sits in the system tray, monitors popular development ports, and the moment it detects an active server it creates a large QR code so you can test on your phone immediately.

Built with:

• Tauri v2 + React + TypeScript + Rust
• Digital Brutalism UI (monospace, neon green, sharp corners)
• System tray + optional Windows autostart

How it works:

1. Start your dev server (npm run dev -- --host for Vite/Astro)
2. EnvTunnel detects it automatically (ports 3000, 4321, 5173, 8080, etc.)
3. Scan the QR code from your phone - done.

Repo: github.com/hsr88/envtunnel

Feedback welcome!

Hello,

I've made a spall free tool please sheck

https://github.com/balyakin/mergetyp

Hey everyone, I've been gradually working on this project for a bit, and I thought some people here might like what I've made :D

TL;DR:

Ditto is a system-wide ASCII keyboard visualizer that mirrors your live keyboard inputs in real time, even when the terminal isn't in focus. It automatically syncs with your native terminal color scheme for a pretty neat and interactive eye candy.

Attached some sample layouts as well with different color schemes, to show how it would fit into a terminal multiplexer setup that has a code editor, active servers, test suite, etc. Perhaps you might like it :D

I don't want to bloat this post with a bunch of details, so you can check out the repo instead if you wanna know more.

>

If you find this cool, I'd appreciate a star ⭐ :)

Builders-welcome post with the substance up front (disclosure: I'm the maintainer). OmniRoute is a free, MIT, self-hosted AI gateway — one OpenAI-compatible endpoint over 237 providers — built around two problems: runs dying on a provider 429, and tokens bleeding on tool/log output.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

Fusion — an ensemble mode for the hard steps. Beyond simple routing, there's a fusion strategy that fans a single prompt out to a panel of different models in parallel and then has a judge model synthesize one best answer (mixture-of-agents, built in). It's cost-aware, so easy turns stay on one fast model and it only fuses when the step is worth it.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

It's 100% local (zero telemetry, AES-256-GCM at rest), MIT-licensed, has a prompt-injection guard on every LLM route, opt-in memory, and runs on npm, Docker, desktop or your phone via Termux.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute · Site: https://omniroute.online

Would value a critique of the routing/compression architecture from this crowd.

Open Source Palantir

We're building OSIRIS - The Open-Source Palantir Alternative

Just launched at osirisai.live - a free, open-source global intelligence platform:

-Real-Time Tracking:

-10,000+ commercial, military and private aircraft live on a 3D globe

- 2,000+ satellites including ISS

- 1,400+ worldwide CCTV camera feeds

- Earthquakes, wildfires, nuclear facilities and severe weather

Built-In OSINT Tools (no installs needed):

Nmap port scanning from the browser

- DNS record lookup and enumeration

- WHOIS domain intelligence

- SSL/TLS certificate transparency

- BGP routing and ASN lookup

- Threat intelligence and IP reputation

All running on a 3D interactive globe with day/night cycle, 20+ live API feeds, and a SIGINT news aggregator.

Live: https://osirisai.live

GitHub: https://github.com/simplifaisoul/osiris

Free. Open Source. No sign-up required.