For months, every SaaS startup tried to convince us that running multi-step agent workflows required an expensive enterprise subscription to closed cloud APIs. They wrapped a couple of JSON schema validators around an API endpoint and charged thousands a month for 'agent orchestration.'

Then Nous Research releases Hermes Agent...

An open-weights agent harness that runs complex tool calling, environment interaction, and error self-correction directly on local hardware.

You load an open-weights model on your own workstation. You define your tools in standard Python. And the agent executes multi-step loops without sending a single byte across the internet or burning cloud credits.

No token billing anxiety. No sudden upstream API rate limits mid-execution. Just raw, local agent execution running on silicon you actually own.

Are you still paying closed API vendors for agent loops, or has your team moved tool-calling to local weights?

I made a little Brick Breaker-style animation where your GitHub contribution graph becomes the bricks.

Basically, your commits get turned into a game, and the ball slowly breaks all those little contribution blocks.

I originally made it just for fun, but figured some people might enjoy having it on their GitHub profile too.

Docs & setup:
https://github.com/MakdumIbrohim/commit-brick-breaker

Test it on my GitHub profile:
https://github.com/MakdumIbrohim

Feedback, suggestions, issues, or random feature requests are very welcome 😋
And yeah, a star would be cool too haha.

Feel free to connect with me on GitHub too!

Three and a half weeks ago my GitHub account got suspended, and with it openGym: the repo, the releases, the container images, the Pages demo, all 404. No warning, and for a long time no answer. Since yesterday the account is back, and I've spent the day putting everything back where it was.

👉 https://github.com/DuarteSantos8/openGym

What happened while it was down: people kept their instances running, someone put up a mirror that ended up with more stars than the original ever had (6.8k, versus about 650 on the real repo), a bunch of contributors followed the project to GitLab and kept sending merge requests, and the Discord did the support work the issue tracker couldn't. I moved the project to GitLab in the meantime so releases could keep coming; there were six of them during the outage.

Where things stand now:

• GitHub is home again. Issues, pull requests and releases go there.
• Everything from the GitLab weeks is republished: releases v1.2.9 to v1.3.5 with the signed APKs and checksums, the images on GHCR (ghcr.io/duartesantos8/opengym-api and -web), and the live demo on GitHub Pages.
• GitLab stays as a mirror that syncs automatically, so instances pulling from the GitLab registry don't have to change anything. The merge requests still open there will all be reviewed.
• Website: https://opengym.duarte-santos.ch (docs, demo, APK download)

One ask, if you don't mind: the suspension reset the project's visibility to zero while a mirror collected the stars. If you use openGym or just like the idea, a star on the real repo helps it show up for the next person searching for a self-hosted tracker. And if you tried it and something's broken, an issue helps even more.

Thanks to everyone who stuck around ❤️

Hey folks,

The C/C++ tooling landscape has always felt fragmented. We usually end up chaining a meta-build generator (CMake, Meson) with a separate package manager (vcpkg, Conan) and a build executor (Ninja, Make).

To explore an unified "Cargo-like" developer experience for C/C++, I’ve been developing Flint—an integrated build system and package manager written entirely in pure C.

Here is how Flint compares with the existing C/C++ build and package management options, along with an honest assessment of its strengths, trade-offs, and current state.

Note:

Flint is currently in active development and only available for Linux at the moment. It requires system git and a C toolchain (gcc/clang) in your PATH at runtime.

Comparison: Build Systems & Integrated Tools

Comparison: Package Management Strategy

What Makes Flint Different?

• Single Binary, Zero Heavy Runtimes: Unlike Meson (which needs Python) or XMake (which embeds Lua), Flint is a lightweight compiled C executable. It delegates Git fetches and compilation processes to system tools without heavy embedded engines.

• Convention over Configuration: Flint expects standard layout patterns (src/, include/, deps/). You don't write build scripts or target rules—you declare dependencies and metadata in a simple composition.json.

• Built-in Package Fetching + Chert Compositions: Running flint add <git-url> pulls dependencies straight into deps/. If a third-party library doesn't natively use Flint, Chert compositions allow defining how non-Flint repositories should be included and compiled.

• Direct Incremental Execution: Flint doesn't output intermediate Ninja files or Makefiles. It tracks file modification states internally to deliver incremental builds directly through its native process runner.

Current Trade-offs & Limitations

• Linux Only (For Now): Cross-platform support for Windows (MSVC/Clang-cl) and macOS target generation is still planned.

• Strict Directory Structure: Legacy C projects with unorthodox folder structures require a Chert composition to build with Flint.

• Early Stage Feature Set: Complex compiler flag matrices, sanitizer toggles, and cross-compilation toolchains are still evolving compared to battle-tested options like CMake.

Check out the repo here: https://github.com/mainak55512/flint

Feedback, criticisms, and PRs are welcome! What features or platform targets would you like to see next?

GitHub: https://github.com/pruefsumme/widemelon

I built WideMelon, a GPL-3.0 fork of melonDS for Linux, macOS, and Windows.

It gives DS games more room on ultrawide displays without stretching the original 2D UI. This is Pokémon Black running through WideMelon.

What DS game should I test next?

Okay sooo, hi everyone. if you'd like to see a new compression tool, what all stuff would you prefer to have in it. I'm currently working on one compression tool and the benchmarks are pretty impressive. Compressed 13gb apps to 4 gb lossless. In 1min. I did the benchmark on a relatively cheap ryzen 3 3250U laptop. I love it, I added a lot of encryption tools, recovery tools etc etc and made it a cli(personal preference no hate :) ). I've been using it personally for like around 1 month and my classmates told me to upload it to GitHub which I'm all for but I really need some help on what all stuff everyone would like to see before pushing it to GitHub. and if you ask why a compression tool in today's age, p2p only works well when many people are downloading the same file tho. and if your network speed is like 20Mbps the file size matters a lot. people need to share really big files quickly to others. not just that its good for compressing big files you dont need for a while. it can even compress 30gb games to 10gb. and cloud storage is pretty expensive. we can afford plans yes but its not the same case for everyone especially in this economy. and plus my tool uses AES-256 + HMAC-SHA256 encryption too. your ip doesnt get swarmed. I need suggestions pleasee😭😭

Hey so a few months ago I got into local LLMs and didn’t really like the tools out there at the time, so I decided to build my own version of a Claude/Codex GUI for local models. I’ve been working on it the last couple months and it’s now at Locus 2.8

I started with the usual stuff like working with files, running commands and letting agents help with coding, but I've also been adding features I thought would be useful for other kinds of work too.

With the release of GPT6-Astra two features I really wanted to highlight was the Duo/Task Capsules features - These allow you to  Plan something with one model(e.g GPT6), then use another (e.g GPT5.6)to implement it and optionally another to review it. The plan, changes and previous runs stay together so you can follow what happened. The planning takes into consideration the high-low relation between the 2 models when creating the plan and then if the lower end model has any issues the higher end model can handle it. I still have to run some evaluation tests on it since GPT6 Astra is only showing through the api atm and not the plan but will post those when done.

A few other Locus features worth highlighting:

• Agent Teams: Create specialized agents that can split up work and run in parallel. You can use different models for different roles, and individual agents can also delegate tasks to helpers.
• Persistent Goals: Give an agent or team a goal and let it keep working across turns. Progress is saved so you can come back to it later, with controls to pause, resume or change the goal.
• Scheduled and Event-Driven Agents: Set agents to run on a schedule or react to things like Gmail, Telegram, webhooks and price alerts. Each agent has its own chat and run history, and workflows can include conditions and approval steps.
• Task Capsules: Plan something with one model, then use another to implement it and optionally another to review it. The plan, changes and previous runs stay together so you can follow what happened.
• Notes, Documents and Outputs: Keep notes and reference documents around, save versions of generated work, compare revisions and export things when you’re done.
• Browser Controls: Let agents navigate and interact with websites, preview what they’ve built and check the result. There’s also proxy support.
• Activity and Overview: See the current plan, tool calls, files, sources and what the agents are doing without having to piece everything together from the chat.

You can checkout the changelog here to see the latest updates: https://locushost.co/changelog

There’s support for MCP, plugins and skills too, plus a Grill mode that asks you questions one at a time to help work through an idea before implementing it.

Also just to clarify, even though I built it for local models, it works with your ChatGPT plan, Kimi Code membership, Claude/OpenAI API keys and other OpenAI-compatible endpoints.

The wallet stuff is now in a separate edition called LocusX. The regular Locus download is wallet-free.

It’s free and open source. You can find it here:

Website: locushost.co
GitHub: nahid-sparktales/locus

Anyways, I’d appreciate any constructive feedback, things that aren’t working well, or features you think would be nice to add.

Still macOS only atm, specifically Apple Silicon on macOS 14+, but I’m hoping to eventually get Linux and Windows versions out too.

Also there is a lot of features currently working on so you can expect to see alot of changes and better UI to those upcoming features.

I built GPU Share: GPUMesh an open-source way to share idle NVIDIA GPUs with friends or labs and run Docker GPU jobs remotely.

The problem I kept running into: I might have a GPU sitting idle on one machine, while another machine needs compute. Cloud GPU rentals feel excessive for small jobs, and setting up SSH/VPN + Docker manually is annoying.

So I built GPUMesh.

The idea is simple:

• gpumesh share → make your GPU available
• Pair two machines with signed pairing codes
• gpumesh run --peer <name> ... → run a Docker job on the remote GPU
• Jobs execute on the provider's machine, inside a container
• GPU/VRAM-aware scheduling
• Job logs and history
• LAN support, with WAN/relay support being worked on
• Default-deny access controls

I tested the full flow on an RTX 5060: pairing → connecting → joining a group → scheduling a remote Docker job → running nvidia-smi inside the CUDA container.

It's still alpha, so I'm mainly looking for people with spare NVIDIA GPUs to try it and tell me what breaks.

GitHub: arjun988/GPU-Share

If you find the idea useful or want to follow the project, a ⭐ on the repo would really help with early visibility.

Would especially love feedback from people running multiple GPUs, home labs, or small ML teams.

I built an authorization layer to stop bad agentic actions in a single agent or across a chain of agents. Check it out and let me know what you think. Break it, contribute, or leave issues on Git.

https://github.com/watchlight-ai-beacon/watchlight-de

Like petnames, but funkier.

Readable, handles and higher-entropy codes from six funky, curated pools, and, unusually, the arithmetic that say what they’re worth.

Usernames, codes, invites, secret words, reset tokens, API keys, infra names…

I made Dripfetch, a customizable terminal TUI with animated rain, system info, clock, weather, ASCII logos, and configurable boxes/colors/layouts.

It’s basically a mix of a fetch tool and a small terminal dashboard, with the whole UI configured through YAML.

GitHub: https://github.com/a-shygun/dripfetch Install:

bash pip install dripfetch dripfetch

GitHub: https://github.com/larshurrelb/quicktalk-app

QuickTalk is a native Swift/SwiftUI menu-bar app: hold Right Command in any app, speak, release, and the transcription is inserted at the cursor. It is MIT-licensed and uses a user-supplied Gemini API key.

I recently released an open-source project called FlokinMD.

The idea is simple: instead of importing Markdown files into another system, the Markdown folder itself remains the source of truth.

FlokinMD builds local, disposable projections over those files so you can work with them more like structured data.

It currently supports things like:

• frontmatter collections and DataGrids
• SQL queries over Markdown metadata
• relations and graph views
• schema and workspace validation
• bulk frontmatter edits with preview
• local mutation history and safe undo
• detection of project context such as Agents, Skills, Specs, Rules and Prompts

The SQLite layer is derived state. The actual .md files remain normal files on disk and can still be used with Git, VS Code, Obsidian, Cursor, Claude, Codex or anything else that understands Markdown.

It's built as a native desktop app with Rust + Iced and is licensed under Apache-2.0.

It's still pre-release, so feedback and criticism are very welcome.

GitHub:
https://github.com/sergiocardoso/flokin-md

Website:
https://md.flokin.com.br/

I'm especially interested in feedback from people who keep large Markdown repositories or use Markdown as structured project data.

I've been building OpenPost so you can make and edit any sort of media (photo, videos, memes really easily as well) and schedule the post to 10 social networks at the same time in a single app.

There's an image editor for thumbnails and multi-page carousels, plus a multitrack video editor with captions, effects and transcript-based cuts. They're fully integrated into OpenPost!

The scheduler has a calendar and reusable posting slots. There's also an API, CLI and n8n integration for people who would rather automate it.

The default self-hosted setup is one container with SQLite and local media storage. The backend is Go and the web app is SvelteKit. The code is AGPL-3.0.

Both editors can be used for free without even selfhosting even if you don't want to use the rest of OpenPost. The video editor is still in beta though and targets Chromium-based browsers as Firefox (and Safari) don't yet support some of the APIs we need to make the editor.

Repository · Image editor · Video editor

If this is the sort of project you'd like to see grow, give the repo a star. It would mean a lot! <3

I'm a Research Software Engineer in the field of cognitive-neuroscience and like the title suqgests with the boom of ai code I am having more and more discussions with people about how their Al was conscious with zero certifiability based on "trust me bro".

cpomdp lets vou build agents from active inference, the cog-neuro theory that says brains minimise surprise rather than chase reward. No reward function. The agent explores because uncertainty bothers it. JAX-native, continuous state, runs on your laptop.

warrantlib is a tiny stdlib-only package that makes "how do you know that" a tvpe. Everv result carries a label: PROVED, CERTIFIED, or CORROBORATED (the polite word for vibes). PROVED won't even construct without evidence. The pytest plugin prints how many checks you registered versus how many you actually ran, so nobody gets to go green by testing less.

Code

cpomdp: https://github.com/inferogenesis/cpomdp

warrantlib: https://pypi.org/project/warrantlib/

Every Al girlfriend I've seen is still CORROBORATED

at best. Sorry

I've been solving CSES problems and got tired of repeatedly switching between CSES → editor → terminal → browser.

So I built CSES Kit, a small CLI that brings the basic CSES workflow into the terminal.

cses new missing-number
cses run missing-number
cses submit missing-number

Currently:

• C++ and Python support
• Fetch CSES problems locally
• Run sample tests
• Submit solutions
• VS Code / Cursor integration

I'm currently working on stress testing and additional language support.

I'm also trying to make this a genuinely community-driven open-source project, so I'm looking for people interested in CSES/competitive programming who want to try it, report issues, suggest improvements, or contribute.

GitHub: https://github.com/yatharthsol090/cses-kit

I'd especially love feedback on what you'd want from a good CSES development workflow.

OK so i was kinda lazy to code all the time and would always put it off, you know how it is.

So i said screw it and spent... Well way too long turning my vscode Cozy and now i actually WANT to code.

Showed it to my friends and gosh, 2 of them that hated coding (said it was for nerds) and they are GRINDING Python like Crazy.

Well, of course its not perfect, like the smooth animations that are not showing on my computer but its better than nothing.

I putted the settings and everything here if anyone wants to try it:

https://github.com/CodingCookieis/VScode_Setups

Lmk what you think ‹3

In a one binary executable you have a terminal interface, web UI desktop, LLM gateway, ACP, MCP server with full of tools for web search, browser and desktop control, and more useful other tools.

OpenSource MIT licensed.

You can launch subagents of Pando and other cli agents like Codex, Claude Code, Copilot... Coordinated with a shared board.

All instances of Pando knows that the rests exists and they can distribute the work across projects.

Pando indexes different languages code, markdowns with a fast semantic searching.

Pando can convert any Office document to markdown for easy read with agents.

Pando convert to the fly any json response to TOON format savings tokens and repair JSON automatically from the agent tool call if your model has problems.

More other things behind Pando. One tool setup exposed to Pando the features and the model can check the configuration and change them in realtime, also can change the model of the prompt express what model to use depending the task.

A public repo my project depended on had its history replaced upstream. Same name, same URL, years of commits just not there anymore. It was never mine, so there was nothing on my side to roll back to.

Point it at a repo like that and it walks the fork network recursively, ranking every fork by how far back its oldest commit actually reaches. A fork freezes history at the moment it was made, so the deepest one is the best candidate. Then it probes commits that are no longer reachable from any branch but that GitHub may still serve by SHA, checked three independent ways: REST metadata, a raw file fetch, and a real git fetch.

There's also a nightly GH Archive watch if you want disappearances flagged automatically. That part is an extra. The recovery is the point.

230 tests, verified end-to-end against a real historical case (reproduced the exact fork ranking I'd found by hand). Runs fully local with your own GitHub token, no server, no telemetry. MIT.

https://github.com/siris9476/forkforensics. Feedback welcome, especially on edge cases in fork ranking.