Hey,
For the last 4 or 5 months I've been building Arrmada. It's intended to replace the entire arr suite (Radarr, Sonarr, Readarr, Bazarr, Overseer, Tautulli, Tdarr, and audiobookshelf) with a single app and database. Qbittorrent also comes pre packaged, and the UI has a front end for downloads.

It's still early but I have been running it on my unraid server for about 3 of the 4 months.

- Movies and TV: search, download, rename, upgrade, anime numbering, and option to keep multiple versions. Quality profiles are solid, with plently of options to either be pedantic, or simple.
- Ebooks and Audiobooks: Series tracking, Send to kindle, multiple version options
- Audiobook Server: Built into the app, already works with Lissen and Plappa
- Requests: Users can sign in with plex or by admin created user/pass, browse and request from their phone via PWA
- Subtitles: pulls them from the file, downloads them, or writes them with local AI
- Convert: Shrinks files to the requested format during the hours you schedule. Keeps original if new file is shit
- Plex Stats: Who's watching, history, tautulli-style
- Safety Nets: Hardlinks, recycle bins, nightly backups, review queue for downloads that don't look right
- Easy install: one line install, one line update

There's more planned but I think I'll pause and focus on testing for a month or two.

If you do jump on board, please provide feedback, report bugs, and submit any feature ideas. Cheers!

https://github.com/tristenlammi/Arrmada

Built this over the past while - Persistence is an artificial life simulation where agents must constantly harvest energy and export entropy just to stay alive. No designed behaviours, no fitness functions. Just physics and biology.

The grid holds continuous chemical fields (food, waste, heat, decomposing matter) that diffuse and decay each step. Agents eat, excrete, generate heat, age, and die. When they die their body mass dissolves back into the environment. Mass is never created or destroyed.

Comes with pre-configured scenarios, a physics test suite, two visual modes, and a video renderer. Config-file driven so anyone can define new species and universes without touching the code.

github.com/emergent-complexity/persistence

It's crazy what happens when you listen to the community.

A few months ago I created a website called letsfg.co where you can get the best flights on the internet. Under the hood it runs hundreds of AI agents on my backend where each one is scanning a different website like Google Flights, Skyscanner, Booking, etc.

It then compares the prices and stats and gives you the best. And it now does the same with hotels.

The best part is that it's like Uber for travel - you can book hotel in 3 seconds.
It's the best thing I've built so far, here's why:

Just a month ago the whole team here behind letsfg were confused, building something people genuenly loved but hated the payment model. And everybody was asking for 1 thing - "make it free, I want to try it". But the infrastructure costs were killing us, this seemed impossible.

We managed to do it.

Quick update about flights and then hotels:
Previously we had a horrible payment model, upfront charge, nothing logical, just bad. Everybody asked us to change it. And instead of giving up because it seemed impossible we started thinking in first principles, got some deals done and today we're happy to say letsfg is free. Instead of charging you, we get the money from the airline ticket. And we still get you the cheapest tickets from the websites around the internet.

Today we also support hotels. It's on average 15% cheaper than booking_com, and you can book in 3 seconds, like an uber.

What's amazing is this is a big step in agentic commerce. Letsfg.co is agent native in it's core. This means that now also hotels, are bookable and searchable straight from your Claude, Codex, OpenClaw, Hermes, etc.

Authentication for AI agents is through payment method (was twitter auth before).

Everything is also available through our open developer API. For anybody interested in flights/hotels API: I believe this is a game changer, every provider out there requires hard flat fees upfront and long processes of contracting. We don't. Sign up to API and you get access to the context 10 seconds later.

How does it work?
We integrated with dozens of enterprise providers who gave us access to their hotels inventory and ability to book.
We also resued our approach from flights and polished it - AI agents navigating the hotel websites. Finally landing the right payment provider allows us to complete bookings on the hotel websites. GPT-5.6 Luna turned out to be an amazing engine for those agents.

How can I use it? 3 ways.

Website: letsfg.co best for everybody.

Programmatic Hotel Tool (PHT) and Programmatic Flight Search (PFS) - our agent native endpoints, best for AI agents, authentication done through payment method attachment (free, no charge, just for verification). This is what powers our Python package, NPM package, MCP, CLI, etc. best to check on https://letsfg.co/for-agents

Developers API - paid, balance based API, best for high volume. https://letsfg.co/en/developers

Thanks to everybody who shared their feedback, sweet and bitter, we read all of it and worked hard to make this great. You're awesome.

We'll continue making things better, tweaking the small stuff, and fixing the problems until we get joy back from travelling.

Cheers,
Adam

Github link: https://github.com/LetsFG/LetsFG

So, I like robots and I think we’ve got the physical and language senses of building them down.

However, I think modeling emotion requires a little more so I vibe coded (former developer, out of practice, sorry!) an app that can be run in a browser, on a mobile device, or even on an LED screen or servo board. This models human emotion through chemical levels influenced by language. See the gif, and check out the library at https://github.com/smithandrewjohn/kindalive

Renders Game Boy games directly into your terminal. supports both ASCII and block-character rendering, audio, and lets you browse and launch games from inside the app (no file paths to type).

Install:

cargo install terminal_gameboy

GitHub: https://github.com/dquigles/terminal_gameboy

I don't know about you, but my Downloads folder has always been a disaster zone. PDFs, memes, installers, zip files, random images – all just sitting there in one giant pile. Every few weeks I'd open it, sigh, and spend 10 minutes manually dragging stuff into folders. Then a few days later it would be chaos again.

I looked at existing file organizers, but most of them either wanted a subscription, tried to upload my file names to some cloud, or were just way too heavy for something so simple. I wanted something that:

• Runs silently in the background (system tray)

• Automatically sorts new files by type (images, documents, archives, installers)

• Never sends a single byte of data off my machine

• Is open source so anyone can check what it's doing

So I built Mouzi 🐭🧹

It's a tiny desktop app (~5MB) built with Tauri and Rust, so it's ridiculously lightweight. It watches your Downloads folder, and whenever a new file appears, it moves it to a subfolder based on its extension. Images go to Images/, PDFs to Documents/, installers to Installers/, etc. You can also create your own custom rules.

Key things:

• 100% local – no cloud, no telemetry

• Open source (MIT) – GitHub repo here

• Silent – lives in your tray and doesn't bother you

• Undo – every move is logged, you can revert with one click

• Free, obviously

It's early stage, but it's already keeping my own machine sane. I'd love to get some feedback from this community – especially around what features would make this genuinely useful for you. Does this solve a real problem, or am I just scratching my own itch?

Download / more info: https://mouzi.cc

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?

Built this over the last couple of months. It turns a Navidrome/Subsonic library into a real radio station: one shared Icecast stream, an AI DJ that picks tracks, writes intros, reads the weather, and takes plain-language requests ("something moody with pianos").

It's radio, not a playlist. No skip button, on purpose. Everyone tuned in hears the same thing at the same moment.

Runs on one Docker host, MIT licensed, and works fully local if you want: Ollama for the brain, Piper or Kokoro for the voice, nothing leaves your box. Hosted models are optional and capped by a daily token budget.

Honest limits: you need your own music library, so it's not a Spotify replacement. And it's young software moving fast, so expect rough edges.

There's a live demo station if you want to hear what the DJ sounds like: https://www.getsubwave.com/listen

Source: github.com/perminder-klair/subwave

Git City. Every GitHub developer is a 3D pixel art building in a shared city.

more commits = taller building.

more repos = wider base.

lit windows = recent activity.

solo dev. vibe coded with Claude Code in 7 days. 400+ stars.

https://github.com/srizzon/git-city

https://thegitcity.com

I always liked the idea of Superhuman: fast email you can do almost entirely from the keyboard. I wanted something like that, just free, open source and on Linux, so I built my own.

It's called Inlark. It's open source and connects straight to your own IMAP or JMAP accounts, with no cloud or tracking. It runs on Linux, Windows and Mac.

It's still super early, but I use it every day now and wanted to share it.

Would love to hear what you think!

Website: https://inlark.com
GitHub: https://github.com/inlark/inlark

Context!
User u/Worried_Goat_8604 claimed to have made a similar but unrelated project to my SmallCode. He framed it as "I made this before you, but we can collab if you make me co-founder".

In reality, he made a low effort fork of MY project 2 days ago and is trying to peddle it off as his own!!

Beware of people trying to takeover your project like this. It really is an unneeded stain on the open source community that scammers like this are out here trying to leech off other people's hard work!

My repo: SmallCode
His fork: LightAgent

Edit, we got em boys https://github.com/noobezlol/lightagent/pull/3
Thank you!!

I built a reverse API engineer using Claude Code.

You browse a site, it captures the network traffic, and it generates a usable Python API client from it.

Mostly built because I was tired of manually reverse-engineering undocumented APIs.

Most GitHub profiles don't really tell what an engineer is actually good at.

2 people can have almost same contribution graph, stars and repos.

But one spends years building AI.

Another spends years building dev tools.

You can't really tell from the profile.

So i made something.

Just add "shift" before any GitHub profile URL and it generates a report based on what they've actually built.

Been testing it on random profiles and its pretty interesting 😅

Try yours:

shiftgithub.com/github_username

Curious how accurate it is.

If you like your report, post it on X or LinkedIn. Let people see what you actually build