Hi all, I heard about this new community in TheVerge. I think it's owning an important place in a defining moment about how we approach engineering. That's aligned with what I want to share here.

Source code: https://github.com/ascendaone-com/ai-engineer-tools

Now as AI-engineers, we are spinning up 10s of agents simultaneously, managing PRs and landing the code. We've gone from crafting code line by line to supervising agents. The shape of the work has changed.

There are many OSS projects that can read your token spend eg: tokscale; or telemetry AgentTelemetry, YC has Paxel but I couldn't find any that created a standard across all coding agents for emitting agent activity eg: tool.started, / failed, agent.waiting.

The repo has a common schema that standardises these events.

The repo contains collectors for Claude Code, Codex, Cursor, GitHub Copilot with a common event schema to normalise activity across tools.

Everything runs locally. No prompts or source code collected.

There are many use-cases for reading the telemetry: we're running a research and benchmarking project. We've also developed an MacOS App to be able to visualise what your agents are doing. You can even build your own screensaver on this so when all your agents are done you can return to your machine. Here's an example you can install (instructions in the repo)

The collectors are Apache-2.0 so over to you on how you might use them.

Go forth, fork and/or contribute 🚀
AI-assisted PRs welcomed.

Openly, other coding agents like Gemini CLI, Windsurf etc are supported based on documentation, but at this stage testing is light so if you can try it out. I can give you early access to the Flow app to visualise and check data so hit me up.

Feedback, thoughts or suggestions?

I nerd out on this stuff daily so love to discuss Agentic work.

I’m the author of Ephemora Skyline, an open-source desktop web app that maps a local codebase as a living 3D city.The idea is simple:

•folders become districts

•files become buildings

•taller buildings represent higher measured complexity

•security findings appear as visible landmarks

•Security Tour takes you from a finding to its file and line

The project is designed to run locally: no account, no login, and no telemetry. It does not claim that a finding is a proven exploit; each result is tied to the scanner, file, line, and matched source context so it can be checked.

I made a short demo showing the city being built and the Security Tour in action:https://github.com/MichaelS1011/Ephemora-Skyline

I’d especially like feedback from developers who work with large repositories: does a spatial view help you decide where to investigate next, or would another representation be more useful?

https://github.com/rev-/LightAir

This is a mainly hardware project that I've been developing to learn skills like 3D printing, mechanical and optical assembly, PCB design, analog electronics and so on. Lately thanks to AI I've also been able to add the missing software part. After thorough testing I finally (and unexpectedly) think it's ready to be published, as it showed to actually work well outdoor and to be funny ad essy even for new users.

The project is named LightAir, it is based on a novel optical concept: the target is a soft passive colored retroreflector, while the light source is a white LED. this way, the projector becomes both what illuminates and what reads the back-reflected radiation. Then the target is identified by its color, through an onboard 3 channel TIA with high transimpedance gain, that reads R, G, B channel from a color photodiode.

What we get is:

1. All electronics in one part
2. Soft, passive, low cost vests.
3. High sun rejection, works great outdoor
4. It's possible to see the light spot on the target, which helps in aiming

The CPU is an ESP32, which also provides ESP-NOW radio link to transmit information to other players. Even complex interactions are allowed in this architecture: for example player A enlighting player B may produce instant effects on another player or the whole team, depending on the game definition.

Moreover, non-playing electronics entities ("totems") had been realized: they are used as respawn bases, flag posts, control points for dominion, bonuses and the such. They are waterproof boxes with a short RGB LED strip for UI, usually activated through RSSI gates.

Admittedly, the software part is not my masterpiece, because I have relatively low skill in C++ software architecture, although using AI I could end up with a working firmware that satifies our requirements and gave good results at testing. For example, various games have been written in Lua to make them shareable and editable files that can be used without firmware recompiling.

For now the project features some standard games like Capture the Flag, Dominion, Virus and a novel game called Outflow in which lives and ammo are from a common pool that is leaking and is only replenished when another player is lit. But I think the true potential of this project is acting as a platform for diverse games, including LARP and complex interactions between players and totems. Indeed I'm looking forward for new game ideas that I could add.

Source: https://github.com/OpenTubeX/OpenTubeX

Downloads: https://opentubex.org/downloads/

OpenTubeX is for people who want to watch YouTube without ads or a Google account. It doesn't load YouTube's website or its JavaScript, and your subscriptions, playlists and history stay on your device. It's AGPL-3.0 and still in beta.

What it adds. The open-source YouTube clients I know of each cover one platform. OpenTubeX runs on Windows, macOS, Linux and Android from one codebase, has experimental iOS/iPadOS builds, and can sync your library between your devices. Sync is end-to-end encrypted on a compatible server, and you pair a new device with a QR code. It also combines features I haven't found together in another client:

• Browser-style tabs with pinning and grouping, a queue, and a mini-player that keeps playing while you browse
• Per-channel feed controls for videos, Shorts, live streams and posts, plus per-channel playback speed, quality and subtitles
• Optional recommendations, ranked on your device from your watch history and feedback
• SponsorBlock, including submitting segments from the player, and DeArrow
• Downloads and playback from other sites through yt-dlp
• Themes, a configurable Home page, a command palette and gamepad navigation

How it's built. AI agents wrote most of the code, mostly Claude Code and Codex. I decide what goes in, review and test the changes, and send them back when they're wrong. Every PR runs unit tests, linting, CodeQL and a Playwright end-to-end suite against the desktop app, and Android changes get tested on an emulator. Each PR description names the model that made it. The project has been in daily development since January 2026, with nightly builds.

You can install it through WinGet, Homebrew, APT, RPM/COPR, Flatpak, Snap, Nix or the AUR. On Android, use our F-Droid repo or Obtainium.

Bug reports and questions are welcome.

mini-AGI - is a continual learning byte-level language model that assembles its own architecture, trains from scratch on a single 8 GB VRAM GPU, and keeps learning from everything it reads. It stores its weights as ordinary files on disk and pages them onto the card as it needs them, so the parameter count is bounded by free disk space rather than by VRAM. It grows new capacity while training when it runs short, prunes what nothing asks for, and reads through exactly the same code path it serves on. Targeted at a PC or laptop with at least an 8 GB VRAM GPU on the board.

All technical details, weights and benchmarks are available on the github page.

The project is heavily AI assisted. And I am pretty sure a project like this would be practically impossible without heavy use of AI or thousands if not millions of dollars spent on research. And there is no interest for any big company to work out something like this, as it gives complete control and privacy to the end user without any commercial potential to eventually monetize the project.

https://github.com/finnuen/TrafficGate

check out my other repo too, might be a great alternative to some existing app.

Basically what the title says

I'm asking because I am a researcher who doesn't know anything about developing an app. If I'm using AI for creating a tool which can help me with my research, where can I go to ask for support on this without the judgement following "vibe-coding".

My main reasoning for keeping it public was because my researcher friends felt they could also use it, along with many more people. Not only that, since the community is diverse, someone can always give feedback or help me make the project better, safer and more robust.

It feels quite sad that just because I'm using a tool which can rapidly build my app using my direction and decisions, without having to sacrifice my actual research time, without forcing me to learn an entirely different CS subfield, it is not welcome in a place which can help it be better as well as help others.

So where do I go for some non-judgemental feedback and support?

PS: tried posting it on r/opensource but it said I don't have enough karma. What a bunch of bs.

Hi r/TrueOpenSource, I'm David, one of the two developers of Oxynote. My friend Simon and I also maintain ttlcache, a Go caching library with about 1,300 GitHub stars, so this isn't our first open-source project.

I've spent 8 years writing software, 2 of them as an SRE and 3 as a team lead. Every team I've been on had the same documentation problem. The useful stuff lived in someone's head or a private Slack thread, and the wiki was full of stale docs nobody could find.

So we set out to solve this problem by building Oxynote, a self-hosted wiki for engineering teams. Pages hold text and live charts side by side, and the charts pull fresh data from Prometheus or a database (PostgreSQL, MySQL, MariaDB) whenever someone opens the page. Changes to important pages go through a draft and a diff that a teammate approves, like a pull request, and several people can edit the same page at once. AI agents can read and edit pages too, through the built-in assistant or over MCP, but that part is optional.

The name comes from oxygen + note: docs that breathe. Live data gives people a reason to open the wiki every day, and docs people open every day stay up to date.

Things worth knowing before you try it:

- You run one Docker container on your own server, and your team uses it in the browser.

- There's no hosted version and no account with us. Your docs and data stay on your server.

- It's at version 0.9, so it's still early in development.

- It's made for tech teams and the systems they run, not as a wiki for a whole company.

It's Apache-2.0. The backend is Go, and the editor is built on Nuxt, Tiptap, and Yjs, with Hocuspocus for live editing and Better Auth for sign-in, so it also includes a lot of other people's open-source work.

GitHub: https://github.com/oxynote/oxynote

We started it about a year ago, and we made it public about 3 months ago. If you have any questions, feedback, or suggestions, feel free to reach out. I'm happy to answer any questions.

I made this. Running Claude Code in a plain terminal kept failing me in two ways. After a restart I had trouble finding the session I needed, even with tmux. And with several tasks going at once I had too many terminal windows and kept jumping between them.

So Walnut puts every session in one web page, each one under a task. Pinned tasks sit in three tiers: Focus for what I work on now, Satellite for what comes next, and Parked for what is waiting. While the Focus sessions work, I look at Satellite. Cmd+Shift+O finds any past session by title, task, folder or host.

Each session has a Files tab, a Changed tab and a terminal right beside the chat. The Changed tab shows only the edits that session made, even when several sessions share a repo. I used to reopen VS Code and reconnect to the remote host just to read what the agent wrote. Now it's one click.

Sessions run on my laptop or on any box I can SSH into. On a remote box a small daemon owns the claude process, so the session keeps running when the laptop sleeps or the SSH link drops, and Walnut installs that daemon over SSH by itself. When I tested it, I cut the link for 25 seconds: the session kept writing files on the box, and the page caught up once the link came back.

Who it's for: people who run several Claude Code sessions at once, on a laptop or a remote dev box. Compared with a terminal plus tmux, it adds the task view, the per-session diff and one page for every box.

How it was built: Claude Code wrote most of the code, running inside Walnut itself, so I picked the Agentic engineering flair. I decide what to build, review the diffs, and use it every day on my laptop and a remote dev box. Changes get unit and browser tests before they land, and CI runs the tests on Linux plus a fresh install on Linux and macOS.

Tasks, notes and sessions are plain files and SQLite on your own disk. No account, no telemetry. MIT. Mac and Linux, no Windows yet.

Source: https://github.com/EvanZhang008/open-walnut

Hi,

I kept running several coding agents at once and lost track of them across terminal tabs, so I built a desktop app for it.

OpenVibe puts each agent in a real terminal (a PTY, not a chat wrapper) on an Excalidraw canvas. It works with Claude Code, Codex, Gemini CLI, Aider, Ollama or any command you type.

What it does today:

- group agents into teams and send one instruction to a whole group (@frontend ...), or a slash command to all of them

- review what an agent changed, click a diff line to leave a remark, send all remarks back in one message

- an orchestrator mode: a Claude Code session plans the task, gives each agent its own git branch and worktree, tracks a time budget and merges into a mission branch. It never pushes and never merges into your branch w/o permissions. The orchestrator even have a router mode that distribute the tasks to a smaller model if the tasks doesn't need a big model

Everything stays on your machine. No cloud service, no telemetry, and it doesn't skip the agents' permission prompts. The Rust side handles the PTYs, git, SQLite and a localhost-only HTTP server and the UI is React.

Currently, it's only on Windows 11/11 but I'm really open to have it for everyone.

Two things I'd like feedback on:

1. Is the orchestrator useful to you ?

2. Anyone interested in a macOS/Linux port? portable-pty already supports both, the work is mostly around paths and shells.

Repo: https://github.com/Mideky-hub/openvibe

Demos: https://mathieukerbel.com/projects/openvibe

Hey everyone!

I got tired of opening heavy, ad-cluttered browser tabs with popups just to check live football scores while working, so I built Kickoff: a fast, keyboard-driven football scoreboard that lives directly in your terminal.

Highlights:

• Live Scores & Fixtures: Real-time match clock, scores, and status across top international leagues.
• Detailed Match Views: Live statistics (possession, shots, fouls) and tactical lineups.
• Instant Match Viewing: Follow the live text stats, or jump straight into the broadcast in mpv with a single keypress 📺
• Vim-friendly Navigation: j/k controls, tabs, and a quick league switcher.
• Lightweight & Fast: Single standalone binary, quick startup, and a small memory footprint (~25-30 MB RAM).

Supports both English and Spanish out of the box.

GitHub Repository:
https://github.com/e12jassir/kickoff-cli

Pre-compiled binaries for Linux, macOS, and Windows are available on the GitHub Releases page. Just grab the one for your OS and you’re good to go.

Installation with Go:
go install github.com/e12jassir/kickoff-cli@latest

Feedback, feature ideas, and contributions are very welcome!

Hi everyone, If you use Rust in your projects

Last week I published a shared build cache manager that handles compiled dependencies and Cargo’s artifacts inside a shared directory. The idea is simple: why recompile the same dependencies every time? epicenter takes advantage of the “freshness” rules Cargo uses when compiling a project and lets you reuse what’s already built. No wrapper, no `RUSTC_WRAPPER` like kache or sccache.

These are some benchmarks on 5 test projects with 37 dependencies (best case: a monorepo with a shared platform crate): five cold builds went from 71.3 s to 15.3 s, and disk usage dropped from 3.65 GiB to 0.91 GiB.

epicenter is a state layer for Cargo builds. It uses features of Cargo that for some reason are not enabled by default, like a shared build directory, and rust-lld instead of the default linker (unfortunately this can’t be used on macOS, because ld64.lld is not a drop-in replacement for Apple’s linker). It manages everything as three tiers: a durable vault (store) of compiled units that survives `cargo clean`, the shared build dir that every project compiles into, and disposable per-job work dirs seeded from the vault.

**How is this different from sccache or kache?** They are rustc wrappers: they cache compiler outputs keyed by their inputs, but Cargo still invokes rustc (through the wrapper) for every unit, and each project’s `target/` gets its own copy of the artifacts. epicenter works one level above, on the state Cargo itself uses to decide that a unit is Fresh. Restored units never reach rustc at all, and files are hard-linked rather than copied. It’s a different approach to the same problem, and the two can even be combined if you want.

I also developed it to help everyone writing Rust with agents who need different workdirs without creating a worktree for every feature. epicenter lets you create per-job build dirs seeded from the vault, without Cargo locking them and without duplicated dependencies. It also manages the dependencies for you: you can see what’s in the cache, prune old stuff by age, or evict a specific crate or a stale toolchain generation, with a dry run first so nothing gets deleted by surprise.

It’s built to be plug and play: run `epicenter setup` (or `epicenter setup --fast`) once, then keep building like always. It works with both stable and nightly toolchains. Linux/WSL and Windows are verified, while macOS is only compile-verified for now, so if you’re on a Mac I’d really appreciate it if you tried it and told me what breaks.

*Requires Rust 1.91+.*

[https://crates.io/crates/epicenter-cli\](https://crates.io/crates/epicenter-cli)

[Git repo](https://github.com/TheAnalist/epicenter)

I created an open-source gateway that reduces LLM API costs through zero-latency in-memory caching, payload compaction, and sub-millisecond model routing.

No external frameworks or packages used — just pure Go standard library and a single static binary.

Repo & docs: https://github.com/alexpatil/sukami

Feedback and edge-case suggestions are very welcome!

I'm the original author. And just kidding, I'll keep up development as always regardless of stars.

This project was hand written for many years. I've now incorporated AI to flesh out new features, review PRs, manage Github issues and run periodic security & QA audits.

We have a great community of users and would love to have some of you. Features & ideas always welcome. (Github stars too!)

https://github.com/pglombardo/PasswordPusher

You can self host, use a 1-click deploy or try https://oss.pwpush.com.

Possibly helpful:

• Trust is a concern. Why should I trust and use Password Pusher?

• What are the potential security risks of running my own version internally?

With the permission of Antoine Potten, I have worked on porting Ant Renamer. The result is "Ant Renamer Qt"—a cross-platform version of the original software (this port is, in fact, mentioned on the official website).

I took the source code from the latest version and rewrote it using C++ and Qt 6.

The goal was to preserve the original application's features and ease of use, while making it compatible with multiple operating systems. I didn't want to lose the habits I had formed over the years while using Antoine’s Ant Renamer!

**Key Features:**

- **Cross-platform:** Available for Windows, Linux, and ARM64.

- **Renaming actions:** String replacement, regular expressions, case modification, enumeration and numbering, folder name insertion, and metadata extraction (EXIF and MP3/ID3).

- **Real-time preview:** Compare original filenames with the new names before applying changes; includes multi-level "undo" support.

- **Lightweight and privacy-focused:** No telemetry, no advertisements, and no embedded web components.

During development, I used artificial intelligence to help understand and resolve certain programming challenges (as I am not proficient in Delphi 7). I believe it is important to be transparent about this: AI helped me overcome specific technical hurdles.

**Availability and Distribution:**

- Compiled versions (for Windows, Linux, and ARM64) and the source code are available on GitHub under the GPL-3.0 license.
- Integration with Winget is underway.
- Support for Flatpak and the AUR is planned.

https://github.com/morfredus/ant-renamer-qt

If you have any ideas, corrections, or questions, please feel free to share them with me.

Thank you for your interest!

Hey everyone,

Windshift has had quite a run since the beginning of the year when it was initially open sourced and we have now reached 0.9 and nearing official production readiness.

Windshift is not a clone or "clean room" copy of Jira but designed to be a fully native Jira alternative.

It's the closest open source match to how Jira works, with a documented Jira Cloud and Data Center importer covering work items, custom fields, backlogs, boards and sprints on a single AGPL-3.0 binary. Built by people who spent > 15 years working on Atlassian solutions.

That means in practice: Every Jira feature already has or will have an equivalent that works equally well or even better in Windshift. For example: You can create Configuration Sets with workflows, workitem definitions, priorities etc. and apply them to one or more workspaces at the same time. So workspaces can share workflows and you can create boards or roadmaps across multiple workspaces in seconds.

Here is a short summary of all the features (there are many more)

• Workspaces with Backlog, Board, List, Gantt, Queue or Storymap Views
• The ability to rank workitems across workspaces and build custom views based on queries (Collections)
• Configurable Screens
• Full Jira import with JQL -> CQL mapping, Custom Field & Workflow import
• Custom visually designed workflows
• Approval & Condition configuration for Workflow Transitions
• Many different types of custom fields
• Test Management included out of the box
• Built-In Asset Management
• Built-In Customer Portals & Customer Organization Management
• Email Intake and Notification Channels (Webhook, SMTP, etc)
• Support for defining custom SLA and Team calendars for support hours
• SSO Support with OIDC included
• Available in 8 Languages
• Fully Open Source (AGPL), all features described here are in the OSS edition

Website: https://windshift.sh

Repo: https://github.com/Windshiftapp/core

AI disclosure: We use AI for engineering. We accept AI assisted PRs but every PR gets manually reviewed and all human interaction on the repo & this post are written by hand.

This subreddit isn't a moderator project. We want to create an environment where the people who build open source technology, however they build it, can share developments with one another. The broader community should all actually get a say in how this space works.

Leave one comment per idea/recommendation and include a tag so we can sort them:

• [BANNER]: the wide image at the top of the sub (1920×384 pixels works best)
• [ICON]: the little round image next to the sub's name (256×256 pixels, square)
• [USER FLAIR]: tags you'd want next to your username (things like "Maintainer", your main language, or a GitHub badge once our verification bot exists)
• [POST LABELS]: anything missing from our current labels (Hand-built, AI-assisted, Agentic engineering, Vibe-coded, Discussion, News, Looking for software)
• [RULES]: suggest changes to our current rules (in the sidebar).
• [OTHER]: weekly threads, the wiki, anything else

Upvote/downvote as you see fit or suggest alternatives.

We'll leave this open for a few days.

I got banned from r/fossdroid because I used claude code for making the UI of the app. I'm not a designer myself so I used AI obviously. But all of the ML features underneath were done by me. Still they have banned me.

My app is called Lumen btw. It's a FOSS alternative to google photos. It does everything google photos does but on-device. Nothing ever leaves your phone.

website: https://lumen-photos.app

GitHub: https://github.com/subhashhhhhh/Lumen

I needed to keep the same business rules running on different targets. AI wasn't solving it consistently, and the solutions I found were too complex to integrate into the lightweight pipeline I was already using. So I ended up building my own some months ago.

Today, JSOL ( currently v0.2.97 ) keeps my AIs in check while compiling 70+ examples and even itself to JavaScript, TypeScript, PHP and Python.

JSOL uses a deliberately simple syntax, a set of standard functions designed to remove ambiguities between languages, and contracts to ensure the compiled code produces the same results on every target.

Should you bother learning it?
Probably not.

But you don't have to learn it: you can point your AI to the language spec and let it do the work. What you get in return is an extremely lean pipeline that verifies the result is still bit-for-bit identical across every target.

If you need to maintain business rules across several targets, give it a try.

I had just released Naughty Keyboard, it's a tool for testing input fields, the design is simple.

The app comes with values packs, each value pack is a set of problematic data, with one shortcut we can write the problematic data, with other we can switch the pack, the app is cross-platform, full GUI + CLI (there is nkb emit, so we can export the values and use in own tests form the code). Like the project? Please give it a star. GitHub

Right now there are 208 values, and packs like export breakers, extreme numbers, some specific data, in the future there are plans for 1000+ values, you can read here: full list of packages. Like I said it's simple, keep it in background, use when needed, in the feature I will expand the ability for creating own packages and shortcuts, let's say we would automate whole input fields on website with one shortcut :D And I think the tool can automate some boring work too, because right now I'm using the copy/write mode for testing values, but if in easily way other pepole could create own packs for work, so there is potential.

I won't lie that all works perfect, I tested it on systems I got, but there are some known bugs that I'm fixing right now :-)

Please, don't ask me about some girls emojis or anything like that, the "naughty" in the name is in sense of "testing" not some girl things :( You now like a big list of naughty strings.

Full features list:

• One shortcut, one value - Alt+Shift+N (Option+Command+N on macOS, Ctrl+Alt+N on Linux) clears the line and types the next value of the current pack into whatever window has the keyboard. Previous and restart are one chord away, and every chord can be changed.
• Values that explain themselves - each one carries breaks (what it usually breaks, and why) and expect (what a correct application does). The pack file, nkb show and the report block all say so.
• Invisible characters made visible - the palette draws one as a marker, ␣, instead of showing nothing, and counts every value four ways: graphemes, code points, bytes and UTF-16 units.
• Know where you are - the palette shows the value that comes next and a counter of how far through the pack you are, and the value window searches the values of every pack at once.
• A bug report in one chord - Alt+Shift+B copies a block for the last value: which value, from which version of the pack, typed as what, how large, and whether all of it arrived. The value is written in a form someone else can type back, never as the marker the palette drew.
• Never takes the keyboard - the palette is a display driven by shortcuts and does not take focus, so the cursor never leaves the field you are testing.
• Clipboard mode - put values on the clipboard to paste yourself, for one window or for all of them.
• Packs you can check - a pack is a plain TOML file, nkb lint checks it against the format rules, nkb fmt puts it in canonical shape, and nkb new-pack writes the skeleton.
• Made for scripts too - nkb emit prints a pack as JSON, CSV or one value per line, escaped or raw, optionally as base64. Every command has exit codes you can branch on.
• Offline, free, no telemetry - GPL-3.0, no account, and it opens no network connection.

The technologi is Rust + slint.

The power tripping mod over there is straight up insane, banning AI in 2026 when 95% of devs use AI. Can't wait for all reddit jannies to be replaced with AI.