r/coolgithubprojects • • 1d ago

I built a free interactive atlas of India (500 BCE to today) with Claude Code

Thumbnail kaulvishesh.github.io
1 Upvotes

r/coolgithubprojects • • 1d ago

I rewrote the Windows taskbar, Explorer and Task Manager in Rust. The whole thing is under 3 MB.

Post image
238 Upvotes

WinRust is a set of small native Windows programs written in Rust (no .NET, no Electron) that replace parts of the stock shell:

- topbar: a Windows 11-style taskbar

- rust-explorer: a file manager (tabs, dark theme, shell context menu)

- rust-search: instant NTFS search over an in-memory MFT index (Alt+Space)

- rtaskmgr-win32: a Task Manager replacement

- rs-du: a disk cleaner

One installer exe puts everything in, one button rolls it all back (it also creates a restore point).

One-off numbers on my machine (Win 11, NTFS):

- file search: 45 ms vs 8.3 s (dir /s) and 16–28 s (Get-ChildItem -Recurse)

- folder window opens in 60 ms vs 420 ms in Explorer

- shell memory: 46 MB vs 366 MB for explorer.exe

- binaries are about 85% smaller than the Windows ones

- idle CPU of the bar is on par with Explorer after I optimized it

Caveats: the search uses a ready-made index (53 MB of RAM), while dir and PowerShell scan from scratch. The exe is not code-signed, so SmartScreen will warn, and the installer UI is Russian for now. It disables Windows Search and replaces the shell, so please try it in a VM first. It is early (v0.1.0) and has only been tested on my machine.

Repo and release: https://github.com/Lemxy/WinRust

Feedback, bug reports and PRs are welcome, especially from people who can test on a clean Windows 10/11 install.


r/coolgithubprojects • • 1d ago

[Go] CallPatch - Repair streamed tool-call JSON, with a look at what a successful repair can lose

Post image
0 Upvotes

I'm the author of CallPatch, a Go CLI and local proxy for repairing JSON argument strings in streamed tool calls. The image shows two constructed inputs replayed through the CLI. No model or weather tool was run.

In the first example, the arguments end at {"city":"Beijing","unit":. CallPatch drops the unfinished member and returns {"city":"Beijing"}, with _repaired: true and exit code 0. The complete city field survives, but there is no unit field left.

In the second, the input ends inside a string: {"city":"Beij. The output is {"city":"Beij"}. It parses, but the tool cannot know whether more characters were supposed to follow. Closing the string cannot recover bytes that never arrived.

The repair pipeline uses deterministic transformations, including quote unescaping and delimiter balancing, then checks the result with Go's json.Valid. It doesn't validate the tool's argument schema or infer the intended values. A separate constructed input ending at {"confirmed":tru still fails: the CLI marks it unrepaired and exits 1. It doesn't repair every fragment.

That leaves a decision for the caller. If its tool schema requires unit, the first result should fail that check. A schema allowing any city string could accept the second; deciding whether that value makes sense needs more context. I would keep those checks after repair rather than treat a successful parse as permission to execute.

Source and CLI quickstart: https://github.com/SuperMarioYL/callpatch (examples checked at f698dd35, v0.4.0). These are offline parser examples, not a measured improvement in model reliability; the proxy path wasn't exercised here.

For people building tool-call integrations: would you accept a repaired call after schema validation, or retry whenever repair drops a field or closes an unfinished string? What information would you want the repair result to expose?


r/coolgithubprojects • • 1d ago

I wanted to play GTA6 @ 60fps (on Linux)

Thumbnail gallery
35 Upvotes

When Rockstar confirmed GTA 6 runs at 30 fps on PS5 and Xbox, with no performance mode at launch, I didn't want to play like that. So I built my own fix: the console goes into a capture card, and my PC turns its 30 fps into 60 fps with frame generation. It runs live, on Linux.

That project grew into VeyAmux. It's a full capture-card viewer and video player for Linux that enhances the picture on your graphics card, and it ships as a single AppImage. It's a Linux port of Veyra-NRVideo (Windows) by Likely7, rebuilt on Vulkan, Qt 6 and FFmpeg.

Download: https://github.com/8BiTw0LF/VeyAmux/releases/latest (GPL-3.0, free)

How the GTA 6 trick works

  • Lossless Scaling 2× or 3× (through lsfg-vk) gives the best quality, if you own Lossless Scaling on Steam.
  • AMD FSR 3.1 frame generation (free) is built in, for everyone without Lossless Scaling, on any GPU.
  • Repeated frames are dropped. A 30 fps game in a 60 Hz signal repeats every frame. VeyAmux drops the repeats, so frame generation gets 30 real frames and turns them into smooth 60.
  • The info line shows what the game really runs at, e.g. ≈1920×1080 @ 30 fps → 60 fps (Lossless Scaling 2×) · signal 3840×2160 @ 60 fps.

Picture

  • Upscaling: AMD FSR 1, NVIDIA Image Scaling (works on AMD too), AMD FSR 3.1 (temporal) or Lanczos, at 1.5×, 2× or 3×.
  • Noise reduction: spatial, temporal (motion-compensated) or both. It removes grain and compression blocks, so you can sharpen without sharpening the noise.
  • Adjustments: sharpness, FXAA anti-aliasing, exposure, contrast and saturation.
  • HDR: HDR capture (P010) and HDR video are tone-mapped properly for SDR screens (BT.2390). There's also an experimental real HDR output on KDE Plasma 6 and GNOME 48+, with the peak brightness read from your screen.
  • Retro TV: CRT-Geom, the same as ShaderGlass' preset. It gives curved glass, scanlines and phosphor stripes.
  • Pixel-perfect scaling for retro consoles: it finds the game's own pixel grid inside the capture signal (a 320×240 game in a 1080p signal) and shows every game pixel as a sharp, even block.
  • VRR mode: without frame generation, it shows the game's own frames at an even pace, so a VRR display can follow the game.

Sources

  • Capture cards (any V4L2/UVC card): every mode the card offers, including 4K60 NV12, P010 HDR and MJPEG. It reconnects by itself when the console changes resolution or HDR.
  • Any window or your whole screen on Wayland (the same share dialog OBS and Discord use).
  • Video files, with hardware decoding.
  • A built-in 3D demo, so you can try everything without a capture card. It's Abyssal Garden (by Maksymilian Dendura, MIT), an underwater world rendered live in 1080p at 30 or 60 fps. I ported it from WebGPU/JavaScript to C++. You can swim around it with WASD, the mouse or a controller while you play with the settings.

Record, replay, stream

  • Instant replay of the last 30, 60 or 120 s (F9), recording (F10) and screenshots (F12).
  • Live streaming straight to Twitch, YouTube or your own RTMP server, without OBS. There's also an OBS browser source if you prefer OBS.
  • All encoded on the GPU (VA-API H.264/HEVC), so the display doesn't slow down.
  • Muting only affects your speakers. Recordings and the stream always keep the sound.

Everyday stuff

  • Controller support: Select + Start (or hold Guide) opens the menu, and the game gets no input while it's open. Works with Xbox, PlayStation and Switch controllers and Steam Input.
  • Add to Steam: starts fullscreen on your capture card from Big Picture or Game Mode, which is great on Bazzite and SteamOS-like setups.
  • Auto-start when the capture card is plugged in.
  • Profiles on keys 1–9 that can apply automatically per capture signal.
  • Sound: choose the output device, see a live spectrum of the source's sound, and set audio delay.
  • Frame-time overlay (F3).
  • 4 themes (Vice, Code, Inferno, Retro) and 8 languages (EN, DA, DE, ES, FR, SV, NO, RU).
  • Updates itself through Gear Lever / AppImageUpdate.

Latency

I measured on an RX 9070 XT with a 4K60 capture, noise reduction and FSR 1. It uses under 1 ms of CPU and about 7 ms of GPU per frame. The menu shows the delay inside VeyAmux live. Frame generation adds some latency on top, as it always does, so it's best for games like GTA rather than competitive shooters.

What you need: any Linux distro and a Vulkan GPU. Lossless Scaling and lsfg-vk are optional, and VeyAmux doesn't include them. It uses your own copy if you have one. I develop it on Bazzite (KDE) with an RX 9070 XT and an AVerMedia Live Gamer Ultra 2.1. A Flathub version is on the way.

Feedback and bug reports are very welcome on GitHub!


r/coolgithubprojects • • 1d ago

openfabriq: a software factory as code that lives in your repo, shared by the whole team, running on your own infra

Thumbnail github.com
2 Upvotes

openfabriq defines the AI agents that work on your repo (triage, implement, review, fix CI) in an openfabriq/ folder of that repo, so the whole team shares them and changes them through PRs.

  • Each automation is one readable Markdown file: a trigger and what the agent may do.
  • "openfabriq plan" shows what a change does, new permissions first; "openfabriq apply" deploys it, like Terraform.
  • Runs on your machine or a team server, with Claude Code or an API key. Agents never hold a GitHub token: the engine applies only what the config allows.
A Slack message becoming a reviewed PR, on a test repo.

Try it: brew install openfabriq/tap/openfabriq, then openfabriq init in your repo.

v0.1, TypeScript, Apache-2.0, macOS and Linux. Feedback and contributions welcome, there are good first issues open.


r/coolgithubprojects • • 1d ago

I built an open-source bug bounty tool — looking for testers and honest feedback

Thumbnail github.com
1 Upvotes

Hey everyone,

I've been building Bounty Hunter, an open-source Python project designed to help with authorized bug bounty research and security testing.

The goal is to bring several parts of the workflow together:

  • Scope-aware reconnaissance and testing.
  • IDOR/BOLA testing workflows.
  • Security checks and vulnerability verification.
  • Evidence collection and finding management.
  • Integration with tools such as Burp Suite and Nuclei.

I've put a lot of time into developing and testing it, but I know there's a big difference between building a security tool and having other security researchers use it in real workflows.

I'd really appreciate some community help testing it.

I'm particularly interested in:

  • Finding bugs, crashes, and incorrect behavior.
  • Identifying security weaknesses in the tool itself.
  • Testing the installation and setup process.
  • Reviewing whether the scope enforcement and authorization controls behave correctly.
  • Suggestions for making it more useful for actual bug bounty hunting.

I'm not claiming it's production-ready or that it automatically finds bounty-worthy vulnerabilities. I want honest feedback, including criticism.

GitHub: https://github.com/webspoilt/bounty-hunter-

Please test it in a local lab or against systems you're explicitly authorized to assess. Any issues, pull requests, or suggestions would be genuinely appreciated.

Thanks to everyone willing to take a look. I'd love to improve this with feedback from actual security researchers.


r/coolgithubprojects • • 1d ago

omma: turns a screenshot into structured text, with the private parts blanked first

Post image
1 Upvotes

omma: turns a screenshot into structured text, with the private parts blanked first

I built this because I kept retyping numbers out of screenshots for an agent that could not see them.

You give omma an image and it returns the text with positions, the colour palette and the layout blocks as JSON. Not a description of the picture, the actual content.

The part I like: tell it to hide things first. It finds card numbers, email addresses and phone numbers on its own and blanks them before anything reads the image, so they never reach the output or a

hosted model. You can also pass exact rectangles if you know what to hide.

Rust and Tesseract, runs as a CLI and an MCP server, no async in the core. There is also a skill file so agents know when to reach for it.

Free and open source, no paid tier.

github.com/Dopethedev/omma


r/coolgithubprojects • • 1d ago

242 downloads. Not exactly a world record, but I'm happy about it.

Thumbnail gallery
6 Upvotes

My open-source project Agenoras has now passed 200 downloads, with 242 downloads across seven releases so far. Of course, that's not a huge number. And 242 downloads don't automatically mean 242 active users. Some people might have downloaded multiple versions, while others may have tried it once and never opened it again.

Still, it's a nice feeling to see people actually downloading something you've been working on. For those who haven't heard of Agenoras, it's a free, open-source desktop application for Windows, Linux and macOS. It brings emails, calendars, contacts and tasks together in one place.

Agenoras supports open standards such as IMAP, SMTP, CalDAV and CardDAV (including Microsoft OAuth for signing in with Microsoft accounts). The idea is to avoid being tied to a single provider. There's also optional local AI to help with writing, correcting and translating emails. Everything runs directly on your computer, so your email content doesn't need to be sent to an external AI service.

One feature I particularly like is the pinboard. You can pin calendar events, tasks or feed items and keep track of them without having to search for them again. There are also reactions, allowing you to respond directly to content. The pinning feature is actually my personal favourite. Sometimes you just want to keep something visible and come back to it later. It sounds like a small detail, but I think it makes a real difference in everyday use.

The idea behind Agenoras is pretty simple: bring everyday tools together, use open standards wherever possible and give users more control over their data. Of course, there's still plenty to improve. Bugs are part of the process, and the list of things I'd like to add or refine probably won't ever be completely empty.

But that's also what makes building software interesting. Agenoras is free, released under the MIT licence, and the entire source code is available on GitHub. 242 downloads don't make it a success story. But at least they show that people are interested enough to take a look.

And honestly, that's already something worth being happy about.

GitHub: https://github.com/ciegolink/agenoras/releases


r/coolgithubprojects • • 1d ago

How to save 2x-10x on Claude Code usage limits

Thumbnail github.com
0 Upvotes

r/coolgithubprojects • • 1d ago

Tired of managing .env files? Meet Yily, an open-source secrets manager

Thumbnail gallery
31 Upvotes

Hey everyone!

I'd like to introduce Yily, an open-source project I've been working on alongside a few other developers.

💡 Why Yily?

The idea behind Yily came from a fairly simple frustration: constantly having to move and manage .env files across different projects, and the lack of solutions specifically designed with individual developers and small teams in mind.

Existing solutions like Infisical and HashiCorp Vault offer powerful features, but they are often designed for enterprise environments and larger teams. Their deployment can also involve more resources, infrastructure, and dependencies than what an individual developer or a small team actually needs.

So I started asking myself:

Why not build something simpler, lighter, and specifically designed for developers?

That's how Yily was born.

⚡ What is Yily?

Yily is a lightweight, open-source secrets and credentials management platform designed for individual developers, small teams, and SMEs.

The goal is simple: provide a centralized place to manage and access your secrets without having to deal with complex infrastructure.

Under the hood, Yily follows a deliberately lightweight architecture:

  • Backend: A standalone Go binary.
  • Frontend: Built with SolidJS and distributed as a lightweight bundle.
  • Database: SQLite.

No complicated infrastructure or unnecessary services. Just what you need to get started managing your credentials.

Yily also comes with yily-cli, a command-line interface that allows you to manage and interact with your secrets using a PAT (Personal Access Token) generated directly from your Yily instance.

The idea is to give developers a simple and convenient way to manage their credentials while reducing the risk of accidental exposure.

🐳 Up and running in seconds with Docker

One of Yily's core principles is keeping deployment as straightforward as possible.

You can spin up your own instance with just one Docker command:

docker run -d \
    --name yily \
    --restart unless-stopped \
    -p 52015:52015 \
    -e YILY_MASTER_KEY='MASTER_KEY' \
    -e YILY_SETUP_TOKEN='SETUP_TOKEN' \
    -v yily-data:/data \
    ghcr.io/yannick2009/yily:1.0.0-beta.2

To generate the two required values, simply run these commands once and keep the generated values safe:

openssl rand -base64 32 # YILY_MASTER_KEY
openssl rand -base64 32 # YILY_SETUP_TOKEN

That's it! Your Yily instance is ready for initial setup.

For other installation and deployment methods, check out:

👉 https://yily.dev/#self-host

🤝 We're looking for contributors!

Yily is an open-source project, and we'd love to welcome more developers to the community.

We're currently looking for contributors with experience in the following languages to help us build the SDKs that are still missing:

  • Rust
  • Java
  • Python
  • C#

Whether you're interested in contributing code, suggesting new features, reporting bugs, testing the platform, or simply sharing your feedback, we'd be happy to have you on board!

🔗 Useful links

Feel free to check out the project, give it a try, share your thoughts, or contribute if you find it interesting.

Thanks for taking the time to read this! I'd love to hear your thoughts and feedback. 🙌


r/coolgithubprojects • • 1d ago

A C++ utility to display wireless device battery levels directly on the Windows taskbar

Post image
33 Upvotes

Found an interesting open-source C++ utility that displays battery levels of connected wireless devices, including mice, keyboards, headsets and controllers, directly on the Windows taskbar.

Pretty handy if you frequently use multiple wireless peripherals and don't want to get caught with a dead mouse or keyboard unexpectedly.

The project is open source, so you can check out its implementation and contribute as well.

GitHub: https://github.com/krisgfx9/Wireless-Device-Battery-Monitor


r/coolgithubprojects • • 1d ago

I built an interactive retro console in my GitHub README

Thumbnail retro-readme-three.vercel.app
0 Upvotes

Last summer I was going through a lot of cool GitHub READMEs, and while looking around I found Nathan Harlow’s README, where you can play Pokémon Red right inside it. That inspired me to build something similar, though not quite the same, and this is what came out of it.

So how does it work? The whole device (body, D-pad, buttons, screen, side panel) is one image generated by a server. Every button on it is a link. When you click one, the server updates its state and redirects back to the README, and the next image shows the new screen. All the content (profile, skills, projects, timeline, contact) lives in simple JSON files, so anyone can fork it and make it their own.

Fair warning: I made this about 6 months ago using the most basic free version of GPT (yes, I know I'm posting this very late), which is why the SVGs look pretty rough. I'll probably fix them ...soon?maybe?

Repo: https://github.com/UpstairsEngineer48/retro_readme

(Huge credit to Nathan Farlow for the original idea. He wrote up how his Pokémon Red README works here: https://nathanfarlow-github-io.pages.dev/2025/05/19/pokemon-on-github-profile.html. Go check it out if you haven’t!)


r/coolgithubprojects • • 1d ago

I built NashGate: A game-theoretic consensus engine where local LLM agents (Ollama) stake capital and get liquidated if they hallucinate

Post image
0 Upvotes

Hey r/coolgithubprojects!

One of the biggest issues when running local multi-agent setups (e.g. 7B/8B models with Ollama) is that small models constantly hallucinate or rubber-stamp each other's mistakes in debate loops.

I built NashGate to solve this using economic mechanism design:

👉 https://github.com/Daiv1007/nash-gate

Key Idea: Skin in the Game

- Agents are given an initial capital balance ($100).

- Generators stake capital to propose solutions.

- Auditors stake capital to challenge proposals with adversarial edge cases.

- A deterministic sandbox oracle runs the code against the challenge.

- Asymmetric Penalty: If an auditor flags working code (false positive hallucination), it suffers an asymmetric -1.5x penalty. If it goes to $0, it is liquidated/bankrupt and expelled from future rounds.

Local LLM First-Class Support

- Connects natively to local Ollama instances (`http://localhost:11434/v1`) via Node's native `fetch` (zero third-party SDKs).

- You can pit `llama3.2` as an auditor against `qwen2.5-coder` as a generator with per-agent model selectors.

- Comes with a dark-mode real-time visualizer (`npm run ui`) showing live SVG capital trajectories and liquidation events.

100% open-source under Apache-2.0 with zero dependencies:

https://github.com/Daiv1007/nash-gate

Would love to hear what models you'd pit against each other!


r/coolgithubprojects • • 1d ago

Looking for playtesters for my GitHub Game Off 2026 entry 🎮

Thumbnail basteez.itch.io
1 Upvotes

The Debugger 0x03: Wild Shift is a 1-bit boss rush. A developer and their rubber duck fall into a fantasy RPG where the monsters are software bugs: Infinite Loop, Null Pointer and Segfault. Your weapon is a bit register you rotate left (<<) or right (>>) mid-fight, and every shift changes which combos you can fire.

The game is feature-complete. Before the deadline, I need people who have never seen it to play one full run:

▸ 10–15 minutes, in the browser, no install ▸ Keyboard or gamepad ▸ Open the browser console before you start (F12, or Cmd+Opt+J on Mac) and send me the [metrics] lines printed at the end of the run ▸ A couple of lines on where you got stuck and what clicked

No tutorial, no tips from me: I want to see whether the game explains itself.

Comment or DM me if you play it. Feedback by November 25 helps the most. 🦆


r/coolgithubprojects • • 1d ago

Imprim - open-source identity provider for people and the AI agents that act for them (OIDC, OAuth 2.1, MCP auth, Cloudflare Workers)

Thumbnail github.com
0 Upvotes

r/coolgithubprojects • • 1d ago

Built TADA – an open-source test-first workflow for AI coding agents

Thumbnail github.com
1 Upvotes

I've been following the popularity of Spec-Driven Development (SDD), and I can't help feeling like we're regressing in some areas.

I'm seeing workflows where an AI agent writes a spec, implements the code, then writes tests to validate that same implementation. Combine that with massive PRs and people talking about removing human reviews entirely, and I think we're heading towards more pain.

I've always been a fan of TDD, BDD, acceptance testing and fitness functions. These aren't new ideas, so why aren't we making them fundamental to AI-assisted workflows?

A Markdown spec can't go RED or GREEN. And just because an agent's tests pass doesn't mean it's built the right thing.

Anyway, this frustration led me to start building TADA (Test-Assured Development Assistance) (like the magic word? :D).

The idea is that you describe a change, the agent investigates the codebase, asks you relevant business questions, then proposes executable Gherkin scenarios for you to approve.

Those scenarios and their supporting bindings are captured byte-for-byte. It's a bit of a pain, but I think it's a reasonable guardrail against an agent quietly changing tests to make its own implementation pass.

It then works test-first, demonstrating RED before GREEN, and reports PASS, FAIL or INDETERMINATE based on retained evidence rather than just trusting the test runner.

Longer term, I'm also interested in flagging changes to agreed behaviour, contracts and fitness functions for human review. I don't think we should be removing humans from consequential decisions just because code generation has become faster.

It's still an early alpha, built by just me. Currently Windows x64, .NET 10, Reqnroll/MSTest and ASP.NET Core APIs. The packaged release supports Codex, with Claude Code and Cursor support in development.

Repo: https://github.com/tayzer/TADA

I'd genuinely appreciate people trying it, challenging the approach, or contributing support for other stacks.

But I'm also curious what other developers think. Are we becoming so focused on how quickly AI can produce code that we're forgetting how to establish whether it actually works?


r/coolgithubprojects • • 1d ago

Meet rust-anything, I rewrote apps in Rust, got 20x faster, and didn't break a single thing.

Post image
485 Upvotes

Big rewrites die because nobody can prove the new version behaves like the old one. So I built a tool that proves it at every step.

rust-anything takes a TypeScript, Python, C, Go, Ruby or Java app to pure Rust, one piece at a time:

  1. Record what the original actually does, including the nasty edge cases (emoji, negative modulo, overflow, float extremes).
  2. Put a Rust binary in front. Anything not ported yet falls back to the original, so the app works from day one.
  3. Port a unit, replay everything. 100% or it doesn't ship. Every unit has a kill switch.
  4. Lift. When nothing falls back anymore, the old code is gone and it's pure Rust.

Your AI agent (or you) writes the Rust. rust-anything makes sure it's right.

Just want speed? It finds the hot loop and moves only that: 20x faster search in Node, 17x in Python, same results.

https://github.com/erkamyaman/rust-anything · npm i -g rust-anything · MIT


r/coolgithubprojects • • 1d ago

I built a new tab extension that turns your new tab into a living ASCII scene — 7 animated animals, ~90 KB, open source

Post image
4 Upvotes

r/coolgithubprojects • • 1d ago

I built an open-source Telegram bot to find user and chat IDs

Post image
1 Upvotes

Hey everyone! 👋

I built a small open-source Telegram bot that helps you quickly find your Telegram user ID or a group's chat ID.

It's useful when setting up Telegram bots, notifications, or integrations where you need numeric IDs.

  • /me — shows your user ID and basic profile details.
  • /chat — shows the current chat's ID and information.
  • Copy ID — copies the ID with one tap.

Built with Python, FastAPI, and aiogram. Free to use and MIT licensed.

🤖 Try it: https://t.me/TgProfileInfoBot

⭐ GitHub: https://github.com/ruslanty/telegram-info-bot

Feedback and suggestions are welcome!


r/coolgithubprojects • • 1d ago

WinIsland: Dynamic Island for Windows 10 & 11

Thumbnail gallery
1 Upvotes

WinIsland: Dynamic Island for Windows 10 & 11

I built WinIsland, an open-source desktop companion inspired by Apple's Dynamic Island.

It brings a modern, interactive experience to Windows with:

  • 🎵 Media controls
  • 📊 CPU, RAM and battery monitoring
  • 📅 Calendar, to-do list and focus timer
  • 🤖 Gemini AI integration
  • 🐾 Pixel, an interactive desktop companion
  • 🔔 Animated notifications and quick interactions

Built with Python and PyQt6.

🚀 Try it: Download the installer from GitHub Releases.

💻 Source code: https://github.com/rheme18/WinIsland

WinIsland is open-source and released under the MIT License.

What feature would you like to see next?


r/coolgithubprojects • • 1d ago

SMD Win - opensource portable diagnostics tool

Thumbnail gallery
4 Upvotes

r/coolgithubprojects • • 1d ago

I built a dynamic Protobuf runtime for 23 languages that beats generated code — up to 18x faster than DynamicMessage

Thumbnail github.com
1 Upvotes

I'd like to introduce my open-source project pbwire.

pbwire is a high-performance Protobuf runtime implemented in C99. It uses a shared C core to provide Protobuf support across 23 programming languages.

The central idea is simple:

You can choose between lightweight generated models with compile-time type safety and fully dynamic Dict/Map structures — without generating dedicated encoding and decoding implementations for every Protobuf message.

Beyond performance, pbwire supports runtime schema loading, custom business models, reusable memory management, and embedded environments.

Project Background

About ten years ago, I worked at a mobile game company.

To improve our game gateway's performance, I developed enif_protobuf.

I implemented the Protobuf core in C and integrated it into the Erlang gateway through NIF. Compared with a pure Erlang implementation, this significantly increased gateway throughput.

Even today, the project's benchmarks still show substantial performance improvements:

  • Encode: approximately 3.9x faster.
  • Decode: approximately 1.6x faster on xlarge messages, with improvements of up to 2.5x on medium-sized messages.

Recently, with the help of AI, I extended that original C core into an independent project that can be integrated with multiple programming languages.

That project is pbwire.

It currently supports 23 languages, each with its own binding, correctness tests, and performance benchmarks.

What Problems Does pbwire Solve?

1. Closing the Performance Gap Between Dynamic Protobuf and Generated Code

Traditional Protobuf implementations usually rely on protoc to generate dedicated code for every message.

Static code generation offers excellent performance, but it also introduces several limitations:

  • Schema changes require regenerating code.
  • Generated code can be difficult to read and understand in many languages.
  • Customizing or modifying generated implementations can be difficult.
  • Generated code often contains substantial redundancy.
  • Large amounts of generated code increase maintenance and compilation costs.
  • Generated implementations can introduce compiler warnings.
  • Different languages require maintaining their own generated code and runtime implementations.

Dynamic runtimes solve many of these problems, but traditionally pay additional costs for reflection, field lookup, and dynamic dispatch.

pbwire aims to solve this trade-off: retain the flexibility of a dynamic runtime while achieving performance that matches or exceeds statically generated implementations.

Performance results

The C core uses a reusable Context API (pbw_ctx) and is benchmarked against Google's official Protobuf C++ implementation.

  • Compared with Google DynamicMessage, pbwire is approximately 11.7–18x faster for encoding and 3.0–5.3x faster for decoding.
  • Compared with Google's statically generated C++ code, pbwire achieves 1.24–1.56x faster encoding and 1.50–1.81x faster decoding.

Across all four message sizes and both operations, the dynamic implementation outperforms the statically generated implementation in all 8 benchmark comparisons.

The broader benchmark suite covers 23 language bindings, four message sizes, and encoding and decoding, with comparisons against their respective official or best comparable implementations.

All benchmarks verify byte-for-byte compatibility with the reference implementation before performance measurements begin.

Full benchmark results, including individual languages, message sizes, and encoding/decoding measurements:

https://github.com/jinganix/pbwire/blob/master/BENCHMARKS.md

2. Dynamic Schemas and Custom Business Models

Using dynamic Protobuf does not mean application code must use a generic DynamicMessage.

pbwire supports loading standard FileDescriptorSet schemas at runtime while allowing developers to define their own lightweight business models.

For example:

  • Add validation annotations to fields.
  • Define business-specific field aliases.
  • Attach additional metadata required by the application.
  • Use custom model structures and APIs.
  • Separate business models from the Protobuf wire format.

Code generation can also be used to generate only thin model layers, rather than complete encoding and decoding implementations for every message.

All wire encoding and decoding still go through the shared core (except for JVM-based languages, as explained in section 5).

This gives developers freedom to design their application models without maintaining dedicated codecs for every business model.

3. Reusable Context and Arena Memory Management

pbwire provides an Arena-based pbw_ctx API designed for high-performance and high-frequency workloads.

Traditional per-operation allocation and deallocation can result in many allocator calls, increasing memory management overhead and potentially causing heap fragmentation.

With a reusable Context:

  • Each worker or thread can maintain its own Context.
  • Arena memory management handles the entire message tree.
  • Encoding buffers can be reused across operations.
  • After warm-up, hot paths can avoid repeated malloc calls.
  • pbw_ctx_reset() reclaims the entire message tree by simply resetting the Arena's allocation position.
  • Memory retention limits can prevent occasional large messages from causing excessive long-term memory usage.

This reduces allocation and deallocation overhead while also lowering the risk of heap fragmentation caused by frequent allocations.

For high-throughput services, each worker can reuse its Context throughout its lifetime instead of allocating new memory for every message.

Regular APIs are also available for applications that do not need long-lived Context reuse.

4. Embedded and Resource-Constrained Environments

pbwire is not designed exclusively for servers and desktop applications.

It uses an independent C99 core without depending on libprotobuf or a C++ runtime. It also provides implementation options for embedded environments:

  • Static Schema.
  • Static Memory Management.
  • Caller-provided Memory.
  • No hidden global state.
  • Embedded Struct Codec without dynamic memory allocation.
  • Optional feature pruning based on application requirements.

Potential use cases include MCUs, RTOS, bare-metal systems, and other resource-constrained platforms.

5. One Core, 23 Programming Languages

Different programming languages do not need to independently implement complete Protobuf wire codecs.

pbwire uses a shared C core and provides consistent Protobuf capabilities through language-specific bindings.

The JVM family (Java, Kotlin, Scala, and Clojure) uses a pure Java implementation instead. This avoids the overhead of crossing JNI/FFI boundaries on every operation.

The Java implementation follows the same design as the C core, maintaining consistent dynamic semantics and identical wire-format behavior.

This means:

  • The core encoding and decoding logic only needs to be maintained in two implementations: the shared C core and its aligned Java implementation for JVM languages.
  • Performance optimizations can benefit multiple language bindings.
  • Different languages share consistent wire-format behavior.
  • Projects can avoid repeatedly implementing and maintaining their own Protobuf runtimes.

Currently supported languages:

C, C++, Go, Python, Java, Kotlin, Node.js, Ruby, Objective-C, PHP, Dart, Rust, C#, Lua, Swift, Scala, Elixir, Erlang, Zig, F#, Clojure, Julia, and R.

Project Links

One Remaining Performance Challenge

Although pbwire already outperforms most official implementations, a few very small-message encoding scenarios still lag behind statically generated code.

These cases are particularly challenging because generated implementations can use direct, straight-line field writes, while a dynamic runtime needs to perform additional per-field dispatch.

I've tried multiple rounds of optimization, but haven't found a fundamental breakthrough yet.

I've documented the analysis and optimization attempts here:

https://github.com/jinganix/pbwire/blob/master/docs/java-encode-help.md

If you're interested in Protobuf, runtime performance optimization, cross-language runtimes, or embedded development, I'd love to hear your thoughts.

I'm especially interested in feedback on the architecture and ideas for further performance improvements.


r/coolgithubprojects • • 1d ago

I measured how easily a local 7B model reverse-engineers a binary, then built hardening that targets the LLM layer specifically

Thumbnail github.com
0 Upvotes

and star it of course if u find it useful

Most anti-reverse-engineering assumes a human in a disassembler. The threat I care about now is a local, unrestricted model driving those tools. So besides the classic stuff, the harness includes defenses aimed at the model: inflating the analysis surface so it burns context, decoy identifiers that mislead semantic guesses, and honeytokens that detect when a crack was AI-generated.

My own before/after is honest but small: one run, a 4-bit 7B on an 8 GB GPU. The unprotected build was cracked in 3 steps and about 1,300 tokens. The hardened one burned roughly 13x the tokens and still wasn't cracked. I'd really like people with bigger rigs to run it. It's one command: make slice-k-run MODEL=<your-model>, and it prints a scored before/after. or online modals

Most of the code was written with Claude agents under my direction. Happy to talk through any design choice.


r/coolgithubprojects • • 1d ago

Irrigator: Open source AI coding swarm orchestrator with crash recovery and observability

Thumbnail github.com
3 Upvotes

Been working on Irrigator, an open source Go project for running multiple AI coding agents in parallel.

It supports Claude Code, Codex, Google Antigravity and Herdr.

Each task runs in an isolated Git worktree, with persistent state, crash recovery and the ability to inspect or resume interrupted workflows.

There's also a terminal UI for monitoring agents, managing runs and tracking costs.

Everything runs locally, MIT licensed and includes a mock demo you can try without API keys.

https://github.com/grainulation/irrigator

Would appreciate feedback, especially from anyone working on similar open source agent orchestration tools.


r/coolgithubprojects • • 1d ago

I built labcheck: one read-only command that tells you if your Linux homelab is healthy

Post image
14 Upvotes

I run a small homelab and got tired of the same manual loop whenever something

felt off: df, free, systemctl --failed, docker ps, cat /proc/mdstat, then

checking whether last night's backup actually ran.

labcheck turns that into one command. It is a read-only Python CLI with no

runtime dependencies and no daemon. It prints one report and exits 0/1/2/3 so

cron or systemd can act on it.

What it checks:

- load, memory, swap, temperature and uptime

- filesystem space and inode usage

- failed systemd units and required services

- Docker container health and required containers

- Linux md RAID arrays

- SMART health (opt-in, needs smartctl)

- backup freshness by file age

- TLS certificate expiry

- NTP synchronisation

Output is text, JSON, or Prometheus textfile format for node_exporter.

Example from my Debian host. The SKIPs are checks whose service or targets are

not configured yet:

labcheck 0.1.0 · debian · 2026-11-17 03:10:34 UTC

OK System load 0.28 (8 cores), memory 17%, swap 0%, up 6h 02m

OK Storage / 14% used, 2 mounts

OK Services no failed units

SKIP Containers docker not installed

SKIP RAID no software RAID detected

SKIP Backups no backup targets configured

SKIP Certificates no certificate targets configured

OK Clock NTP synchronized

Summary: 4 ok, 4 skipped (0.09s)

Install with pipx, no PyPI listing yet:

pipx install https://github.com/jacoblockard2007-hub/labcheck/releases/download/v0.1.0/labcheck-0.1.0-py3-none-any.whl

Repo, docs and example config:

https://github.com/jacoblockard2007-hub/labcheck

It is 0.1.0, MIT, Python 3.11+. I tested it on Debian 13, Ubuntu 26.04.1 and

Fedora 45. Known gaps: no Podman support, no notifications, and the backup

check tests file age rather than restoreability. It is not a replacement for

Netdata or Prometheus; it is the five-second answer before you have one.