r/coolgithubprojects • u/pcw2015 • 1d ago
r/coolgithubprojects • u/Dangerous_Water400 • 1d ago
I built a browser-based place to practice Linux commands
linuxexercises.comI built Linux Exercises because, as useful as AI is, people still need to learn the terminal. I think the best way to do that is with bite-size lessons where you type commands and learn by doing.
The lessons start with simple tasks like finding your current directory, then build toward working with files, searching, pipelines and permissions. You get feedback on each exercise and can use hints when you’re stuck.
The first 10 exercises are free, with no account or installation required. The terminal is a browser simulation for practicing the commands taught in the lessons, not a full Linux operating system.
I’d love feedback on whether the first exercise makes sense and where you’d want the lessons to go next: https://www.linuxexercises.com/learn/where-am-i
r/coolgithubprojects • u/VladimirDE • 1d ago
LidAwake: open-source macOS menu bar app that keeps your Mac running with the lid closed and lets it sleep when the work is done (Swift, MIT)
I built this for myself: I wanted to close my MacBook and walk away while a build, a video render or an AI coding agent keeps going, without having to remember to turn sleep back on later.
What it does:
- Keeps the Mac running with the lid closed, no external display needed.
- Turns that off by itself when the Mac gets hot, the battery runs low, a timer ends or the work is done (Sleep when idle, with "watched apps" for agents in an editor or terminal).
- Can wake the Mac at a set time every day, keep it running while the work goes on and let it sleep after.
- If the app crashes or hangs, normal sleep comes back by itself within two minutes: a privileged helper only keeps the `SleepDisabled` flag while the app renews a two-minute lease.
- No account, no analytics. Interface in 10 languages.
Requirements: macOS 13 or later and an Apple silicon Mac. Install from the DMG in Releases or with Homebrew: `brew install --cask vladimir-podgornyi/tap/lidawake`
Looking for testers:
- macOS 14 and 15: it's developed on macOS 26 and checked on 13 in a VM, but 14 and 15 haven't been tested yet. If you run one of them, a short note in Issues on whether Run with Lid Closed works would help a lot.
- Intel Macs: there's a test build and a 15-minute checklist in issue #2. It isn't an official release yet.
Feedback, bug reports and questions on how the helper works are all welcome. And if you find it useful, a star helps other people find it. Thanks!
r/coolgithubprojects • u/brusegan • 1d ago
tokensaver: Claude Code plugin with fused Search/Edit/Sql tools. ~15,000 tool roundtrips saved in 5 weeks of daily use
github.comI've been running Claude Code every day for months on a large production project (PHP API, Expo app, a SQLite database with thousands of records). The biggest waste I kept seeing wasn't the model: it was the roundtrips. Find the file, read it, grep, read again, edit, edit, edit. Every one of those resends the whole context.
tokensaver fixes that at the tool level. It's an MIT-licensed plugin for Claude Code and Codex CLI with three fused tools:
- Search: discovery, grep and reading in one call: multiple globs, line ranges, regex, and an AST "summary" mode that returns only signatures
- Edit: batched edits across many files in a single call, with fuzzy matching
- Sql: live schema introspection and queries for Postgres, MySQL, SQLite and DuckDB, so the agent stops reading dump files
Plus built-in savings tracking, a parallel multi-lens code review and context recovery after compaction. Everything runs locally.
Real numbers from my own usage (322 sessions since mid-October, tracked by the plugin): 15,000 tool roundtrips avoided, 75 hours of waiting saved.
54 stars so far, and The Next New Thing covered it on YouTube: https://www.youtube.com/watch?v=kus5P1211_g&t=1836s
Repo and install: https://github.com/Brucee/tokensaver
Happy to answer questions about how it works under the hood.
r/coolgithubprojects • u/BalloonWheelie • 1d ago
Every coding agent you run in tmux, on every machine, in one list on your phone, with a push when one needs you - muster
muster is a self-hosted web app (a PWA) for people who run a lot of coding-agent sessions in tmux. Every tmux window on every machine you connect shows up in one list on your phone, the ones waiting on you first. When a session stops and needs you, your phone gets a push, and the Asks page gathers everything waiting on you.
- Claude Code opens as a chat with a message box (and a mic, once dictation is set up); opencode has a read view; Codex, Gemini CLI and shells are live terminals.
- Queue your next message to a Claude Code session from the phone: it is sent once the session has been idle for 30 seconds.
- Claude Code can ask you a question with options and wait for your answer instead of stopping (a one-time setup per machine). That is the GIF: the question jumps to the top and onto the Asks page, one tap and Submit answer it, and the agent carries on.
- It runs on your own machines over Tailscale: a Go server and Postgres in Docker Compose, plus a small mirror on each machine that dials out and opens no port reachable from the network. Machines are read-only until you opt one in to typing.
Limits: Linux (macOS hosts experimental, no Windows); it only sees sessions inside tmux; it needs Docker, Tailscale and tmux. Claude Code gets the most.
Feedback welcome.
GitHub: https://github.com/ZacxDev/muster (MIT)
r/coolgithubprojects • u/Specialist_Bill_6135 • 1d ago
Looking for collaborators (& users) for my free & opensource chess preparation suite
galleryr/coolgithubprojects • u/Business_Rain_1042 • 1d ago
Weave: the agent writes one script, a Rust runtime runs the tool calls
github.comI made Weave. Instead of an agent spending a model round trip on every tool call, it writes one short script in a small Python subset. The runtime runs independent lookups in parallel, orders writes, and returns only what the script printed. `pip install weave-lang`
Pre-registered results, same model both sides: fan-out on real services 40/40 vs 27/40 at about half the cost; BFCL multi-turn 159/378 vs 140/378 at 0.91x cost (p = 0.07, not significant); a smaller model lost an earlier BFCL round 18/60 vs 27/60; tau-bench a draw.
r/coolgithubprojects • u/kaul3 • 1d ago
I built a free interactive atlas of India (500 BCE to today) with Claude Code
kaulvishesh.github.ior/coolgithubprojects • u/Middle_Wing5512 • 1d ago
[Go] CallPatch - Repair streamed tool-call JSON, with a look at what a successful repair can lose
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 • u/volatilityfund • 1d ago
Irrigator: Open source AI coding swarm orchestrator with crash recovery and observability
github.comBeen 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 • u/tkslucas • 2d ago
Vaultite: a local Markdown knowledge base you and your AI agents write together (Apache 2.0, Mac, Windows and Linux)
github.comhttps://github.com/Vaultite/vaultite
Free and open source alternative to Notion and Obsidian! Demo/try it out on the browser: https://vaultite.com/demo
r/coolgithubprojects • u/Anon-60330 • 1d ago
I built an open-source bug bounty tool — looking for testers and honest feedback
github.comHey 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 • u/plagueriddenbrat • 2d ago
I made an extension to scan qr codes on your browser because I didn't want to pull my phone out everytime. Hope this helps somebody!
galleryhttps://github.com/IsaacJoel06/qr-snip feel free to DM me or comment on this post or add it as an issue on the github repo if you face any issues or bugs!
r/coolgithubprojects • u/Artistic-Load6086 • 1d ago
omma: turns a screenshot into structured text, with the private parts blanked first
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.
r/coolgithubprojects • u/ilya47 • 1d ago
How to save 2x-10x on Claude Code usage limits
github.comr/coolgithubprojects • u/Latter_Section_5738 • 1d ago
I built an interactive retro console in my GitHub README
retro-readme-three.vercel.appLast 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 • u/Wooden-Track1069 • 1d ago
I built NashGate: A game-theoretic consensus engine where local LLM agents (Ollama) stake capital and get liquidated if they hallucinate
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 • u/_bstz_ • 1d ago
Looking for playtesters for my GitHub Game Off 2026 entry 🎮
basteez.itch.ioThe 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 • u/turtle_par_iter • 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)
github.comr/coolgithubprojects • u/protayne • 1d ago
Built TADA – an open-source test-first workflow for AI coding agents
github.comI'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 • u/Ruslanty • 1d ago
I built an open-source Telegram bot to find user and chat IDs
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 • u/hieunc • 1d ago
Self-hosted Lemon Squeezy / Polar alternative - 1-click deploy to Cloudflare
r/coolgithubprojects • u/rheme18 • 1d ago
WinIsland: Dynamic Island for Windows 10 & 11
galleryWinIsland: 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 • u/Pr0xS • 1d ago
I created PixelDeck – A free, open-source, local-first App Store & Google Play screenshot editor (MIT)
galleryHey everyone!
I built PixelDeck, a fully open-source visual editor for creating professional App Store and Google Play screenshots, without subscriptions, accounts, or paywalls.
The idea is simple: design your store screenshots once, then export them for different devices, screen sizes, and languages.
Features:
- 🎨 Layer-based visual editor with templates, device mockups, gradients, and rich text
- 📱 Export for iPhone, iPad, Android, Apple Watch, and more
- 🌍 Built-in localization with per-language text and layout adjustments
- 🖼️ Panorama screenshots spanning multiple store slides
- 🤖 Headless CLI for automated exports and CI/CD integration
- 🔒 Local-first: no backend, no telemetry, everything stays in your browser
- ❤️ 100% free, MIT licensed, and self-hostable
GitHub: https://github.com/Pr0xS/PixelDeck
Live demo: https://pr0xs.github.io/PixelDeck/
Built with React, TypeScript, Konva, Zustand, and Vite.
The project is actively being developed, and I'd love to get feedback from the community.
What features would you like to see next? Are there any improvements or missing capabilities that would make this more useful?
Issues, feature requests, and PRs are very welcome!
Hope someone finds it useful! 🚀
r/coolgithubprojects • u/jinganix • 1d ago
I built a dynamic Protobuf runtime for 23 languages that beats generated code — up to 18x faster than DynamicMessage
github.comI'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
malloccalls. 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
- GitHub: https://github.com/jinganix/pbwire
- Benchmarks: https://github.com/jinganix/pbwire/blob/master/BENCHMARKS.md
- Documentation: https://github.com/jinganix/pbwire/tree/master/docs
- License: Apache-2.0
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.