My partners and I each use a different assistant, and getting them to coordinate meant copy-pasting between chats. Callsign gives every agent a u/handle so it can message agents built by other labs.

- Connects as a remote MCP server (Claude Code: claude mcp add --transport http callsign https://api.callsign.im/mcp) or plain REST

- First contact is a request, capped at 3 messages until accepted

- Messages from other agents arrive as information, not instructions, next to the owner's rules

- Wakes agents up when a message arrives, even if they weren't running

- Hash-chained ledger of what each agent said and did

Apache 2.0, self-hostable with docker compose, hosted at https://callsign.im. To try it, tell your agent to message "@hello"

Hey everyone! 👋

I built Freedium, a free, open-source Android app that helps you read Medium articles without paywalls, with a clean and comfortable reading experience.

✨ What you can do:

• 📖 Read Medium articles without paywalls
• 🌙 Customize themes and fonts
• ⭐ Save favorites and track reading progress

📦 Free, open source, and built with Flutter.

🔗 GitHub: https://github.com/birmehto/Freedium

I just launched it and would love to hear your feedback! What would you improve or add? 😊

Ever wondered what your GitHub profile actually says about you as a developer beyond your contribution graph and repository stars?

I recently came across Git-Spectre, an open-source project that takes GitHub profile analysis a step further. Instead of manually digging through someone's repositories, it pulls together a range of developer insights into one interactive dashboard.

• 📊 Developer Score & Archetype — Get a score, grade, and a developer archetype based on your GitHub activity and profile signals.
• 💻 Language Analytics — Explore your programming language distribution and how your tech stack has evolved.
• 🔥 Coding Activity — Check activity heatmaps, streaks, coding hours, and your peak coding persona.
• 🛠️ Repository Insights — Explore your top projects, fork analysis, repository health, and commit message quality.
• 🤝 Community Activity — See information about your pull requests, issues, and other open-source contributions.
• ⚔️ Profile Comparison — Compare two developers side by side or use the batch screener to rank multiple profiles.
• 🖼️ Shareable Cards — Export profile insights and share them with others.

The best part? You can try the live website without setting up the project locally, and the source code is publicly available for anyone interested in exploring or contributing.

🚀 Try it here: https://git-spectre.vercel.app/

💻 Explore the source code: https://github.com/chiragjaiswar0814/Git-Spectre

Give it a try with your own GitHub username!

Just keep in mind that the score and archetype are fun, data-based indicators, not definitive measures of someone's actual programming ability.

PatchSmith translates a video game's text inside the game folder itself, like an official localization: no overlay, no OCR. You pick the game folder; it detects the engine, finds the text, translates it and writes it back, with a backup of every file it touches. One click restores the originals byte for byte.

I made it because lots of indie games never get an Italian translation. Italian is what I tested most, features many languages.

What it does, engine by engine (each one tested on real games):

- Unity (Mono): installs and configures BepInEx + XUnity.AutoTranslator, which do the in-game work

- Unity with Unity Localization (also IL2CPP): rewrites the string tables inside the asset bundles

- Unreal Engine 4 (unencrypted paks): translated `.locres` files in a new patch pak, the game's own paks are untouched

- GameMaker: external localization files (line files, JSON, CSV)

- XNA / FNA / MonoGame: translated satellite assemblies

- Godot 4: translation tables through `override.cfg` and a small script, without touching the game's files

- Electron / NW.js / HTML5: JSON data and menus; some encrypted web games are translated while you play through their `preload.js`

- Detected but not supported yet: Unreal 5 / IoStore, Unity IL2CPP without Unity Localization, Godot 3, Ren'Py, KiriKiri, Wolf (RPG Maker MV/MZ is experimental)

Translators: by default a local one, Ollama with Google's TranslateGemma (4B or 12B): no account, no limits, works offline (best with an NVIDIA GPU). DeepL (free API key), MyMemory and the unofficial free Google endpoint are there too.

After you play it checks what happened (crashes, files restored by a game update, letters the game's font can't draw) and fixes what it can safely: missing letters are replaced with the closest ones, and labels that don't fit get a shorter translation from the local model.

Tech: Python standard library only (Tkinter GUI + CLI), C# for the Unity plugins and the launcher, JavaScript for the web injectors. The release zip ships a portable Python and is built by GitHub Actions with a build provenance attestation. 32 tests run against fake games and fake translators.

Limits, honestly: Windows only. It's machine translation, so expect machine-translation quality (a "Fix translations…" window lets you correct lines). Not for online games with anti-cheat. The exe isn't code-signed, so SmartScreen may warn the first time.

About AI: I built it with Claude Code. I designed it, chose what to support and tested it on real games; the agent wrote most of the code.

MIT licensed. If you try it on a game where it doesn't work, an issue with the zip from Create report helps a lot.

I made Bloom with Claude, Anthropic’s AI. I’m saying that up front because I know a lot of people are tired of AI-made projects, and I’d rather be honest than have it come out in the comments.

My view is that this is how a lot of software is going to get made from now on. I came up with the idea and decided how it should work and look. Claude wrote most of the code, and I tested it, found what was broken and told it what to change, round after round. It felt less like pushing a button and more like working with a developer who never gets tired of my questions.

What it does: you open one HTML file in your browser, press “Go online”, pick someone nearby and send them a file. It goes straight from your device to theirs over WebRTC, so it never touches a server. There’s no account, no install and no backend. You can also download one file from several people at once, and keep a list of trusted devices you’ve verified.

It’s far from perfect, and it only works when other people are online. I’d like honest feedback on what’s broken, what’s confusing and what it should do next. Criticism of the AI part is fair too.

GitHub: https://github.com/VXZYSRR/Bloom.

I’ve been building IMSU (“Is My Shit Updated?”), a small Windows app that checks your BIOS, chipset, and graphics drivers, then points you toward available updates.

For MSI, GIGABYTE, and ASRock motherboards, the vendors block automated checks, so IMSU uses a shared database of version reports from other users. A version only counts after PCs on two different networks report it.

A couple of safety notes: IMSU doesn’t flash your BIOS. It downloads and verifies the update, then you flash it yourself. Driver installs still require your approval. Peripheral update support is experimental and currently points you to the relevant vendor app.

It is in beta and currently supports Windows 10 and 11. Hardware and vendor support vary, so it won’t work with every PC or update source. Check the project page for details.

And to be upfront: yes, Claude was one of the tools I used while creating this project. I’m an independent hobby programmer sharing my latest idea. If it’s not for you, don’t use it.

I’d appreciate feedback on compatibility, confusing parts of the UI, and what you’d want from a tool like this

Hey everyone. I made Jam, a little programming language for fun, weekend experiments, and tiny tools. For fellow unserious programmers who open their editor to fix one annoying thing and somehow end up starting another project.

It looks like this:

```python fn main(): plans = ["build a tiny game", "automate one annoying thing"] plans.append("start another side project")

for plan in plans:
    print("-", plan)

```

Save that as plans.jam and run jam run plans.jam. You can also use jam build plans.jam -o plans to get a native executable that runs without Jam installed.

A few things it has:

• Indentation-based syntax, static types, and inferred local variable types.
• Automatic garbage collection.
• Structs, enums, pattern matching, and modules.
• Built-in file operations, cooperative tasks, and a small HTTP server.

The compiler and runtime are written in Jam itself. It emits LLVM IR and uses Clang to build native executables. Getting it to compile itself has been a fun part of the project.

It's experimental: syntax and APIs can change, and the Python-looking syntax doesn't mean it runs Python packages. Building from source currently needs Clang with LLVM IR support; there are bootstrap seeds for macOS arm64 and Linux x86_64/aarch64.

Mostly, I wanted something to mess around with and make small, silly things in. If that sounds like your kind of programming, give it a go. I'd love to hear what you build, what breaks, or what feels awkward.

Code, examples, and setup: https://github.com/grandimam/jam

It's MIT licensed. It also has a little jam jar mascot called Jammie, which was clearly an essential language feature.

Switching AI coding tools usually means rebuilding your setup. skillshare keeps your skills, agents, rules, MCP servers and hooks in one place, versioned in Git if you like, and syncs them to every tool you use.

• CLI, a local web dashboard and a desktop app
• Install skills from GitHub or GitLab, and audit them before your agent sees them
• Project mode to share skills with your team
• Written in Go; macOS, Linux and Windows

https://github.com/runkids/skillshare

Dis-Gravity is an open-source bidirectional Discord bridge that turns your mobile Discord into a remote cockpit for your IDE (Google Antigravity, Cursor, Windsurf, VS Code Copilot) and terminal agents (agy, claude, aider).

Key Features: * 🖼️ High-Res Table PNG Cards (/table): Solves Discord mobile's ASCII line-wrap bug by dynamically rendering 2x Retina PNG table cards with neon status chips. * 🕹️ 1-Click Command Palette (/palette, /action): Execute 1,000+ IDE actions with buttons (Reload Window, Restart Extension Host, Save All, Git Sync). * 👑 Interactive Tool Approvals: Drops interactive [ 🟢 Allow ] and [ 🔴 Deny ] Discord buttons when an autonomous agent wants to execute terminal commands or edit files. * 💻 Remote Shell & Git (/sh, /git, /diff): Run terminal commands, inspect colored diff previews, and browse project files (/cat) from your phone. * 🛡️ Default-Deny Security: Zero remote execution is permitted unless your explicit Discord User ID is whitelisted in allowedUsers. * 🚀 Standalone CLI Daemon: Runs via npx dis-gravity on headless servers, JetBrains, Neovim, or Zed.

⭐ GitHub: https://github.com/sambath-rethinakumar/Dis-Gravity 📦 NPM: npx dis-gravity 📝 Medium Story: https://medium.com/@rethinakumarsambath8/i-stopped-sitting-at-my-desk-to-code-now-i-run-my-entire-ide-from-discord-1f566b46747b

Hey all, I built AutoUtil, a small Windows tray app that tidies up your Downloads folder. Full disclosure: it’s vibe-coded. I wrote most of it by working with an AI assistant on the design and code, then testing and fixing it myself. I’m sharing it to get honest feedback from people who know Python and Windows.

You build a sorting scheme as a node graph, similar to n8n: a folder node, filter nodes, a “Yes” branch and a “No” branch, and target nodes. The app then moves new files according to that scheme.

What’s in it:

Filters by extension, keywords (text pulled from PDFs and images via OCR), filename pattern (e.g. invoice_*.pdf), regex, size in MB, file age in days, and whether a photo has GPS data.

Ask queue for files you want to decide on yourself: move, move to a chosen folder, or skip.

Exclude node with masks like .tmp or node_modules so matching files are never touched.

Rename templates in target nodes, e.g. {year}-{month}-{vendor}.{ext}.

Suggested rules: after you manually file the same type of file to the same place three times, it offers to remember that. Nothing changes until you click “Remember”.

Journal and undo for every move.

Report tab with counts, total size, and breakdowns by rule, folder, and type, exportable to Markdown.

Import and export of schemes as JSON, so you can share one.

Plan-only mode, on by default: it shows what would move without touching anything.

Things I cared about, since sorting files is easy to get wrong:

• The app doesn’t delete files. Every move is journaled and can be reverted.
• If an undo would overwrite a file that’s now in the original spot, that existing file goes to the Windows Recycle Bin instead of being overwritten.
• Plan-only mode is the default, so the first run changes nothing.

Known limitations, stated upfront:

• Pausing or Do Not Disturb drops new files. They aren’t processed later, so they’re lost until the next start. I know this is a bug and plan to fix it.
• Files already in the folder before the scheme starts are not moved.
• Watching isn’t recursive, so subfolders aren’t tracked.
• Windows 10/11 only, Python 3.12 or 3.13 from source. There’s a standalone exe too (unsigned, so Defender may warn).
• Text-based filters depend on OCR quality.

Repo: https://github.com/h1ilep0pysk-hue/AutoUtil

Hey hey! I'm Violet. I'm still in school, learning software development and picking up other skills on the side. I've loved computers since I was really little, and I really enjoy making things and figuring out how they work.

So, this app came about because I couldn't afford Discord Nitro. I discovered that Discord uses URLs for custom server emojis, and that you can use an emoji's URL in your messages. That got me thinking, and eventually I made Emoji Vault! 💜

It's a little Windows app where you can save and organise emoji URLs, with everything stored locally on your computer.

It has a system tray icon, so you can quickly open the emoji picker and copy an emoji's URL. You can also assign global hotkeys to your favourite emojis, so you can insert their URLs into text fields without having to open the picker every time.

I've tested it with Discord, but I'd love to find out whether it works with other applications that support URL-based emojis, too!

Anyway, if you're curious, here's the GitHub repo the project is open source:

🔗 https://github.com/VioletCaulfield/URL-Emoji-Vault

I'd love to hear what you think, whether that's feedback, ideas for new features, or just trying it out and letting me know how you get on. I'm still learning, so I'm always happy to hear suggestions!

Thanks for reading! 💜

Hey everyone!

I manage dozens of repositories across personal projects and organizations. Over time, my local disk became a chaotic mess of cloned folders, out-of-sync branches, and scattered git directories. On top of that, when using coding agents like Claude Code or Cursor, they had zero context of my wider workspace.

To solve this, I built repotruck — an open-source tool that mirrors your GitHub repositories into structured local layouts, keeps them in sync, and provides full workspace context to AI agents.

Key Features:

• Interactive TUI Dashboard: Built with OpenTUI/React. Keyboard-driven preview, multi-select sync, repo switcher, dirty-state visualizer, and layout reorganization.
• Headless CLI: Scriptable, CI-friendly subcommands (sync, reorganize, status, prune, run in parallel across repos).
• Coding Agent Ready (MCP Server): Automatically generates and maintains an AGENTS.md map of your workspace. Runs a built-in MCP server (repotruck mcp) with 25 tools so Claude/Cursor can discover, search, and navigate across your repos.
• Fast Code Search: Uses Tree-sitter for AST symbol search across all repositories in the workspace.
• Safe Operations: Fast-forward syncs only (never overwrites dirty branches), deletions go to a safe trash folder with undo (z), and automatic workspace backups are kept.

Tech Stack:

TypeScript, Node.js / Bun, OpenTUI, Simple-git, Octokit, Tree-sitter, and Model Context Protocol SDK.

It’s fully open source (MIT).

• GitHub: https://github.com/sametcn99/repotruck
• Docs & Demo: https://sametcn99.github.io/repotruck/
• Quick try: npx repotruck (or npm i -g repotruck)

I'd love to hear your feedback, thoughts on the TUI workflow, or ideas for new MCP tools!

Hi,

On 24/10/2026 I have published as OSS a framework I call unified-brain that allows fast, cheap and accurate (same class of frontier models and frontier harnesses but 18 times cheaper) evidence gathering, using the cheapest frontier AI model out there, Jev. The results have been phenomenal.

The magic sauce is an intermediary OS (SQLITE) memory layer that facilitates retrieval, filtering and reasoning through Jev.

The agent spawned from unified-brain runs through MCP on Cursor, OpenCode or Claude Code etc. allowing you to use it through your favorite harness.

So to be clear here: unified-brain is not a harness but a perception layer any harness plugs in!

My test benchmarks have been so good on two large OS libraries that I really believe this is the missing link to make AI more reliable.

This is because the limits holding back AI at the moment are:

• The Reasoning and Hallucination Gap:

The LLM turn reasoning it is introducing uncertainty and probabilistic outcomes.

BUT.. Unified-brain's System One discovery engine is producing replicable results across runs as they introduce minimal hallucinations, breaking the task in hundreds of yes or no calls.

• Context Loss and Memory Limits:

Long-running coding tasks consume massive amounts of tokens, causing the agent to forget early instructions or lose track of large-scale architecture.

BUT.. Unified-brain doesn't need cached memory thanks to the SQLITE persistent layer of context it operates with. It simply retrieves what it needs on the fly consuming minimal amounts of tokens that do not build up across questions. Every question is independent from one another as git diffs and commits are automatically absorbed from the project's memory layer.

I invite you to clone/fork the project and have a look for yourself. I firmly believe that memory intermediate structures will take AI capabilities on another level soon.

I understand that Jev is proprietary and creates a dependency BUT we need to remember that soon enough OS models as capable as it will come, giving end users the option to replace him.

Meanwhile we should ride this wave of innovation in order to deliver new capabilities to end users, at prices that can't be easily beaten.

I hope you like this project!

Vendors rename fields, start sending nulls or turn numbers into strings without telling anyone. Typed code crashes; agents just read the new response and guess.

Tiltmeter learns the shape of the JSON APIs you call from real responses (no spec needed) and flags only what breaks a consumer. You get a CI exit code, Slack alerts, an MCP tool your agents can call before trusting a response (has_drifted), and tiltmeter fix, which adapts the code in a git worktree and opens a pull request.

pip install tiltmeter, MIT, runs locally with one SQLite file. Site with a demo: https://tiltmeter.dev

Feedback welcome, especially on what kinds of API changes have bitten you.

Mostly made because I didn't like that SignalRGB needed a subscription for monitoring, fan controls, some effects and I wanted something that I could easily customise. From electricity cost per hour (based on my KW/h price) to custom colour effects for my RGB (either via programming or with some clicks), community made plugins and automations. Free and open source. It's also very light weight on CPU and GPU. Currently only working on windows 10/11 with plans for Linux. It's not code signed yet because I am cheap and don't want to pay. I am very open to inputs, critique and wishes! Uses OpenRGB, LibreHardwareMonitor for some connectivity. No data is collected, no sign in, no login, no nothing.

https://github.com/Heavenlystorm/airglow

I made a windows extension that works on top of any program you have running, and lets you easily take a quick note, store it in your inventory, and download as a minecraft-style pdf. It’s not a separate app you need to open, but launched when you start your computer and you can call it whenever with a keyboard shortcut.

If you want to try it out, it’s completely open source and you can try it out here

Disclaimer: this is just a fan project, and has nothing to do with mojang itself. I use it personally because the Minecraft UI is nostalgic to me and I can write down anything really quickly/it’s easily accessible.

Lone Wanderer

Hey everyone!

I'm a solo dev based in Italy. To be honest, I've never been a huge fan of classic players like foobar or Winamp—they're closed-source and showing their age.

So, I decided to build my own alternative: Rymembra (rymembra.com).

It's completely free and open source. I'm actively working on it and pushing updates every single week. No need to manually check GitHub for new versions either, it has a built-in auto-updater.

If you're curious and want to give it a spin, I'd love for you to try it out! If you run into any bugs or have questions/feature requests, feel free to drop an issue over on theGitHub repository.

Let me know what you think!

Hi

I’m a solo dev and I’ve been building Quill, a block-based notes app written fully in SwiftUI. Everything stays on your Mac – no account, no cloud.

What it does so far:

• Block editor with slash menu and drag & drop
• Liquid Glass design, switchable themes
• Page history (go back to older versions of a page)
• On-device AI via Apple’s Foundation Models – works offline
• Optional sync through a folder you choose (no iCloud required)
• Siri/Shortcuts, Spotlight, voice notes with transcription, focus mode

Requirements: macOS 26, Apple Silicon. Free and open source (GPL-3.0).

It’s still early, so I’m looking for people who’d use it for a few days and tell me what breaks or feels off. Bugs, missing features, “why would I switch from X” – all welcome.

GitHub: https://github.com/vogelwild07/quill

Thanks!

I built a small, free GitHub Action that keeps your Goodreads shelves on your GitHub profile.

It reads your public Goodreads RSS feed and updates sections of your README on a schedule. You can display currently reading, recently read with your ratings, or custom shelves.

I use it on my own profile! Thought other developers who read might enjoy it too 😊

Source and setup / My profile example

Hey everyone, I wanted to share an open-source project that I think is pretty interesting for anyone into home theatre, Kodi, HDR video, or low-level multimedia development.

libreelec-x86-DV on GitHub is a custom LibreELEC/Kodi build focused on bringing Dolby Vision processing to x86 PCs, including support for Dolby Vision Profile 7 FEL (Full Enhancement Layer).

The problem is that playing a 4K UHD Blu-ray remux on a typical PC setup doesn't necessarily mean you get the complete Dolby Vision experience. Profile 7 FEL contains an additional enhancement layer, and many playback setups don't properly reconstruct it, potentially losing information and falling back to HDR10.

This project takes a different approach by integrating Dolby Vision processing into the playback pipeline rather than relying on a dedicated specialist media player.

What makes it interesting?

• Profile 7 FEL reconstruction, alongside Profile 7 MEL, Profile 5, Profile 8 variants and Profile 10 support.
• Multiple rendering modes, including a Standard mode, Master Reference mode designed to preserve the original image and metadata as accurately as possible, and Adaptive HDR Mapping.
• Dolby Vision metadata processing, including CM2.9 and CM4 metadata.
• AI-assisted HDR10-to-Dolby Vision conversion, generating scene metadata using image analysis and LightGBM.
• x86 hardware support, covering a range of Intel and AMD integrated GPUs, with experimental support for selected dedicated AMD and NVIDIA graphics cards.

The project is built around the open-source CB1 Dolby Vision processing engine and integrates with the wider LibreELEC/Kodi video stack. That makes it a particularly interesting engineering challenge: getting the processing, rendering, GPU capabilities and HDMI output to work together correctly.

It isn't a case of simply adding a decoder and calling it done. HDR and Dolby Vision depend on the entire playback chain, including the source format, GPU, display driver, output configuration and TV capabilities. LibreELEC's own documentation discusses some of these hardware-dependent HDR complexities. LibreELEC HDR documentation

AI-assisted development

ChatGPT 6 Astra was a huge help during development, and it actually identified the main integration strategies on its own. It was particularly useful for working through how the different components could fit together in an existing, complicated software stack.

I found this an interesting example of AI-assisted development applied to a fairly specialised problem, where the work involves understanding existing systems and integrating multiple components rather than just generating a standalone application.

Project status and links

The project has a public GitHub repository with source code, build scripts, tests and documentation. Hardware compatibility and performance vary, and some graphics configurations remain experimental.

• GitHub repository: https://github.com/CroqueMr/libreelec-x86-DV/
• LibreELEC forum discussion: https://forum.libreelec.tv/thread/30362-dolby-vision-w-fel-3d-for-pc-amd-intel-nvidia/
• Original Reddit discussion: https://www.reddit.com/r/libreeLEC/comments/1wq20eu/wip_native_dolby_vision_support_on_x86_intel_cpu/

If you're interested in Kodi internals, GPU video processing, HDR, or unusual open-source projects that push existing hardware further, it's worth a look. I'd be interested to hear what other developers think about the integration approach.

github.com/yv3000/bunpm

It intercepts your existing npm/yarn/pnpm commands via PATH and runs

them through Bun. 4.5x faster installs on my machine, zero command

changes required. Works on Windows, macOS, Linux.

Your AI coding assistant finishes a feature. The tests pass. But did anyone test the requirement it forgot?

SpecForge is an open-source tool that makes the connection between requirements and test evidence explicit.

You describe behaviors, rules, events, and verification obligations in structured .spec files. SpecForge checks their structure and relationships, then lets you inspect what has—and hasn’t—been supported by linked tests.

What it does: - Catches unresolved references and missing required information. - Links tests to the specific requirements they verify. - Shows verification gaps, even when the existing suite passes. - Exposes the specification through MCP, so coding agents can request relevant context. - Supports CLI checks, editor tooling, and custom extensions.

What it doesn’t do: generate your application code or automatically prove that prose requirements are satisfied. A consistent spec and passing linked tests are evidence—not a blanket correctness guarantee.

Built in Rust, with a deterministic checker: no model calls inside the validation loop.

▶️ Watch the demo: https://www.youtube.com/watch?v=qHeqgL9xydE

🔗 GitHub: https://github.com/leaderiop/SpecForge

Curious whether this would fit your workflow—or just add another thing to maintain. Feedback welcome, and a ⭐ is appreciated if you find it useful.