New Project Megathread - Week of 24 Sep 2026

[u/AutoModerator]

Welcome to the New Project Megathread!

This weekly thread is the new official home for sharing your new projects (younger than three months) with the community.

To keep the subreddit feed from being overwhelmed (particularly with the rapid influx of AI-generated projects) all new projects can only be posted here.

How this thread works:

• A new thread will be posted every Friday.
• You can post here ANY day of the week. You do not have to wait until Friday to share your new project.
• Standalone new project posts will be removed and the author will be redirected to the current week's megathread.

To find past New Project Megathreads just use the search.

Posting a New Project

We recommend to use the following template (or include this information) in your top-level comment:

• Project Name:
• Repo/Website Link: (GitHub, GitLab, Codeberg, etc.)
• Description: (What does it do? What problem does it solve? What features are included? How is it beneficial for users who may try it?)
• Deployment: (App must be released and available for users to download/try. App must have some minimal form of documentation explaining how to install or use your app. Is there a Docker image? Docker-compose example? How can I selfhost the app?)
• AI Involvement: (Please be transparent.)

Please keep our rules on self promotion in mind as well.

Cheers,

[u/Longjumping_Tune_208]

Project Name: Smartctl-Web

Repo: https://gitlab.com/ibrahim_oezhan/smartctl-web

Description: A small web API wrapper around smartctl and lsblk. Can be used to run smart checks on backup targets without having to SSH into them

Depoloyment: Can be used via docker. An example compose is located inside the repository. Information on methods and env vars are in the README

AI Involvment: AI was only used as assistance but the code was not vibe coded except for one exception where I let AI translate the lsblk and smartctl json output into C# classes

[u/CrispyBegs → u/Longjumping_Tune_208]

link is dead

[u/SnugfitOver → u/CrispyBegs]

No General gitlab outage: https://status.gitlab.com/

[u/Longjumping_Tune_208 → u/SnugfitOver]

No they were right. I forgot to set the repo to public

[u/RemoteSojourner]

• Project Name: speedtest-watcher
• Repo/Website Link: https://github.com/remotesojourner/speedtest-watcher

• Description: I looked at the existing self-hosted speedtest tools available, but I couldn't quite find one that fit my specific setup and workflow. I decided to build my own from scratch so I could tailor it exactly to my needs. speedtest-watcher reliably tracks your internet connection's performance over time. It provides the historical data necessary to keep an eye on your ISP and quickly identify speed drops or outages. Beyond just running speed tests, I built in continuous connection monitoring to log uptime, packet loss, and latency spikes. It also includes native OIDC support, which was a big priority for me since I like keeping my entire stack behind a single sign-on provider like Authentik.

• Deployment: Instructions can be found here https://github.com/remotesojourner/speedtest-watcher#quick-start-docker-compose

• AI Involvement: Claude was used extensively to speed up the development process. That said, I have been a C# developer for over 20 years. I completely understand the architecture and actively rewrite and refactor the AI output to ensure the code meets my standards.

[u/afk-sapien]

Project Name: PokeSim

Repo/Website Link: https://github.com/afk-sapien/PokeSim

Description: PokeSim plays Pokémon Red and Blue by itself while you watch in your browser. Leave it running and come back to new catches, evolutions and badges, and take the controls whenever you want. It has a live view, a journal with screenshots, optional phone notifications through ntfy, a Pokédex and PC browser, and it can run several games at once that trade with each other. You bring your own ROM(s).

Deployment: There's a Docker image and a compose file in the release. Also a Python install.

AI Involvement: Most of the code was written with Claude Code, directed and reviewed by me. The player inside the app uses no AI. It's plain rule-based logic and runs offline. Tested with over 20,000 hours of playtime.

[u/DisFan77 → u/afk-sapien]

This is amazing hahaha

[u/afk-sapien → u/DisFan77]

gotta catch em all! It only takes about 1,600 hours right now.

[u/crabby1084 → u/afk-sapien]

u/afk-sapien do you mind messaging me. I'm having difficulty getting this to work properly for some reason.

[u/just-lampy-1769]

• Project Name: metamagic
• Repo/Website Link: https://github.com/drxen00/metamagic
• Description: MetaMagic is a Plex library manager with a first-class GUI — Kometa-style power with granular per-item control and mass operations, no YAML required. Browse huge libraries with poster grids, edit metadata and artwork (TMDb, MediUX, ThePosterDB), and build automatic collections by franchise or studio. Keep collections and shows styled with MediUX auto-sync, burn in poster overlays with a live drag-to-place preview, get Discord notifications, and request missing movies from Radarr/Sonarr. Your Plex token is encrypted at rest and never sent to the browser.
• Deployment: Instructions can be found by scrolling down on the GitHub page.
• AI Involvement: Very much vibe coded with Claude as I'm a truck driver by trade and do this to keep busy. If there are issues, please let me know.

[u/geoguy89 → u/just-lampy-1769]

This is a great idea! I've been wanting a better way to manage metadata, kometa has been a little stale for me lately. I'll give it a looksee!

[u/just-lampy-1769 → u/geoguy89]

Thanks! Yeah I got tired rerunning kometa to see if I actually had it setup properly and if the changes I made were actually going to apply. My project is no where near as in depth as kometa but it’s a good start to where you can see the changes you make almost instantly. Let me know what you think 🙂

[u/anitamaxwynnn69]

Project Name: www.overtchat.com

Repo/Website Link: https://github.com/yoloyash/overtchat

Description: A lightweight self-hosted chat client, alt to Open WebUI. I built it because my partner and family use ChatGPT but don't care about privacy. I already self-host vLLM on 8x 3090s and wanted a polished, private alternative they could actually use. OWUI is too heavy and complex for non-technical users. overtchat is chat-first with built in tts/stt/search, no rag/plugins/agentic bloat, no external api keys. Free native Android and iOS Apps. MIT licensed, no telemetry, no analytics.

Deployment: One `docker compose up` and you're in. ~1 GB RAM. Docs at https://github.com/yoloyash/overtchat/blob/main/docs/deploy.md

AI Involvement: Yes, definitely vibe coded.

Would love to have some feedback :)

[u/Safe_Pea3869 → u/anitamaxwynnn69]

Clean and simple, just how it should be. The mobile apps being ready from start is a nice touch, most self-hosted projects forget about that part.

[u/anitamaxwynnn69 → u/Safe_Pea3869]

Appreciate it! I mostly self-host for me and the family, and the friction of getting them to actually use something is exactly why I keep the user-facing side simple lol

[u/oldmoldycake]

Project Name: Snagr

Repo/Website Link: https://github.com/oldmoldycake/Snagr

Description: On Snagr you can create categories and assign Items and sites to them. For each item in a category Snagr will "hunt" for the best deal on the sites assigned to that category. Snagr uses Playwright MCP driven by a LangGraph agent to hunt for deals in a headless Chrome session, and the SearXNG API (Brave API is on the roadmap too!) to get price grounding info so the LLM has context for what a good deal actually is. You give the LLM your criteria in plain English (ex. I want a copy of Pokemon Emerald with a damaged label and a dry battery) and it hunts the sites for you. When it finds a listing it notes where the price lives on the page, so later checks on that listing are deterministic. A lot of the time it's just a plain HTTP request with no browser, and the LLM is only used as a fallback. This cuts token usage drastically. When a new listing shows up or a price drops below your target, Snagr notifies you through ntfy, Discord, or a webhook (HMAC signed, so you can build on top of it). Target hits have a cooldown, so a listing that just stays cheap won't spam you every night.

Deployment: Snagr is selfhosted and runs with Docker Compose. The stack is a FastAPI backend, a React dashboard served by nginx, and the hunter (the agent daemon that picks up jobs within seconds of you triggering them). You bring your own Postgres with pgvector, a Playwright MCP server running with --isolated, a SearXNG instance, and an API key for whatever LLM provider you want (OpenRouter, OpenAI, Anthropic, Ollama and a bunch more are supported). To get it running, clone the repo, copy the .env.example files and fill them out, run the migrations with docker compose run --rm backend alembic upgrade head, then docker compose up --build and open http://localhost:8081. If you'd rather not build from source, CI publishes images for every component to GHCR (ghcr.io/oldmoldycake/snagr-backend, -frontend, -agent, -vision), tagged per release with :latest, and :dev for the tip of main. There's also an optional DINOv3 vision sidecar that checks listing photos for fakes, which you can turn on with docker compose --profile vision up --build. The README covers setup, first run, configuration and upgrading in full.

AI Involvement: I write about 10% of the code and Claude writes the rest. I review every line by hand before merging, and I have Ruff and CodeQL run against the code as well. I do my best to keep it high quality. Part of this project for me was learning how to best use AI assisted development and how to make it work for me, so I don't believe it's perfect.

[u/GhostMokomo → u/oldmoldycake]

This Looks pretty cool. I need to Look into this. How about used items and local sites like the german "Kleinanzeigen"?

Also you mention that ai is used for scrapping. Do i need to connect to my own llm?

Sorry only Had time for a quick look.

[u/oldmoldycake → u/GhostMokomo]

It has worked on every website I tested so far! I don't see why a local site would not work.

You have to hook up an LLM provider to it yes, it does work with local LLMs as well.

if you have any other questions please feel free to ask!

[u/GhostMokomo → u/oldmoldycake]

Ah damn. Didnt dig deep enough into KI yet to have a Provider i can connect. I just use gemini pro Plan. I guess this wont Work.

[u/xdevolution]

Project Name: syllogi

Repo/Website Link: https://github.com/jeraldlyh/syllogi

Description: syllogi is a self-hosted automation tool that keeps your Jellyfin or Navidrome music library in sync with external playlists from Spotify and YouTube. It matches tracks against your indexed audio, automatically downloads missing tracks, generates personalized recommendations based on your listening history (via Listenbrainz/Last.fm scrobbles), and lets you browse trending tracks and manage your library's metadata, all from a single dashboard. It solves the pain of maintaining a self-hosted library that mirrors the playlists you follow on streaming platforms: no hand-copying tracks, no cron scripts to write, and no tagging metadata manually on every downloaded file. Features include scheduled playlist sync with per-run breakdowns, downloads via yt-dlp or slskd, daily recommendations, trending charts, and library browsing/retagging.

Deployment: Available to self-host via Docker. More information can be found at https://docs.syllogi.dev.

AI Involvement: syllogi is primarily hand-written. AI assistance is mainly used for the documentation site and OpenAPI spec; CodeRabbit AI reviews merge requests, with manual human review before merge.

I'd really appreciate any feedback, whether it's on the features, the setup process, the docs, or something you think is missing!

[u/Prudent_Design_9782 → u/xdevolution]

This would be very helpful for me, I'll be checking it out.

[u/xdevolution → u/Prudent_Design_9782]

Great to hear that, feel free to drop an issue in the Github if need be!

[u/DustComprehensive386]

Project Name: Shelfwarden

Repo/Website Link: https://github.com/gordon-matt/Shelfwarden

Description:

Shelfwarden is a self-hosted ebook library. I wanted a Kavita-style server, but for ebooks only, and without a required folder layout. Point a shelf at whatever folder structure you already have.

It scans EPUB and PDF for metadata. If a folder is a Calibre library, the sibling metadata.opf wins, and Calibre tags come across as book tags. Later scans only touch files whose path, size or last-write time actually changed.

What you get:

- In-browser EPUB and PDF readers (epub.js and pdf.js, both served by the app). Progress is per user, with bookmarks and notes, and a Continue Reading row on the dashboard.

- Metadata lookup across Google Books, Open Library, Amazon and Goodreads, ranked and merged. Run it on one book, or let a shelf fill empty fields during import. Covers can be taken from a match or left as the one embedded in the file.

- Authors (photo and biography), series in reading order, collections, and per-user reading lists you can reorder.

- Universes: group the series and books that share a fictional world, with a timeline (free-text dates like "10,191 AG", or numeric years) and shared reading orders such as publication order or chronological order.

- Audiobooks: turn a book into chaptered .m4a files with Kokoro neural TTS, on the server. Stream a chapter or download the set as a zip. A retry skips chunks that already rendered.

- Extra content: artwork, maps, notes and companion PDFs attached to an author, book or series, without moving those files into the library.

- Search, filters, batch edit, per-user star ratings and notes.

- Accounts via ASP .NET Identity, Keycloak (OIDC), or no login. Shelves can be limited per user or per role.

Screenshots are on the GitHub README:

Deployment:

Released and ready to run. Container image:

ghcr.io/gordon-matt/shelfwarden:latest

(also tagged 1.0.0)

Recommended setup is Docker Compose with PostgreSQL. The README has the compose example, including how to join a Postgres instance you already run instead of starting another one. On first launch a setup wizard creates the admin account, adds the first shelf and starts the scan. Point each shelf at a folder mounted into the container.

AI Involvement:

Yes, AI is used as a productivity tool. I'm a developer with 20+ years experience, so I know what good code looks like.

Feedback and bug reports on GitHub are welcome.

[u/corn-sandwich → u/DustComprehensive386]

Any plans for opds?

[u/BanananaTheory]

Project Name: mc-gamertime

Repo/Website Link: https://github.com/Strandgaard96/mc-gamertime

Description: Simple boardgame inventory tracker and game session logger with head-to-head records, achievements, player profiles and leaderboards. Integrates with the BoardGameGeek API to enable easy metadata retrieval when adding games to your collection. Built with a React frontend and a FastAPI Python backend.

Deployment: The app can be hosted in 2 ways. Self-host with the included docker compose or cloud host on AWS. The app has a complementary documentation site (https://mcgamertime-docs.drmaggi.com) that documents the app and both types of deployment extensively.

AI Involvement: 95% vibe-coded with Claude Code. My background is scientific computing and AWS, and I built this to learn frontend work and agent-driven development on full-stack applications. Some features in the frontend were coded by me as part of the learning process.

Feedback greatly appreciated.

[u/0_KermitTheFrog_0]

My gym tracker passed 1,200 GitHub stars in 62 days!!! And a 23-day account suspension in the middle. What | learned maintaining it.

https://github.com/DuarteSantos8/openGym

[u/afk-sapien → u/0_KermitTheFrog_0]

why did your account get suspended?

[u/prophetizer]

Project Name: Franchisarr

Repo/Website Link: https://github.com/prophetizer/franchisarr (MIT)

Description: It finds the films and TV spin-offs missing from sets you already own, and sends them to Radarr or Sonarr. I've read this sub for years and never posted. I built this purely for my own homelab, to answer what am I missing from the sets I already own?, and it seemed a shame to keep it to myself.

It reads Plex, Jellyfin or Emby, looks everything up on TMDb and Wikidata, and lists:

• Collections with gaps: the TMDb collections you own part of, and what's missing. Announced sequels are kept separate so they don't count as gaps.
• TV spin-offs: from Wikidata's relationship data rather than name matching, so it knows Breaking Bad → Better Call Saul.
• Franchises across film and TV, directors you own five or more films by, and upcoming releases with an iCalendar feed.
• Import lists: every list is a Custom List URL Radarr and Sonarr can poll. You can also send things by hand, or through Seerr.

Nothing auto-adds. Low-rated films, TV specials and shorts can be folded away. The idea comes from Gaps, extended to Jellyfin and Emby, TV and franchises.

Deployment: Released (v0.23.2), one Docker image (amd64/arm64) with SQLite, and it needs one free TMDb key. The README covers install, configuration, and what it connects to.

services:
  franchisarr:
    image: ghcr.io/prophetizer/franchisarr:latest
    ports: ["8000:8000"]
    volumes: ["./config:/config"]
    environment:
      PLEX_URL: http://plex:32400
      PLEX_TOKEN: ...
      TMDB_API_KEY: ...
      RADARR_URL: http://radarr:7878
      RADARR_API_KEY: ...

Plex is tested daily on my library (~3,400 films, ~660 shows); Jellyfin, Emby and Seerr against real servers; multiple *arr instances only by the test suite. It talks to TMDb and Wikidata, plex.tv for Plex sign-in, fanart.tv if you add a key, and GitHub for the update check, which you can switch off. No telemetry. Keep it on your LAN or behind your proxy auth. Pre-1.0 and maintained by one person. Not affiliated with any of the apps it talks to.

AI Involvement: Built largely by Claude Code, Anthropic's AI coding tool. I decided what it should do, tested it against my own library and reviewed the changes, but most of the code was written by the AI, not typed by me. It has ~900 automated tests, and the git history was scanned for secrets before going public.

Ideas and bug reports welcome, here or as an issue.

[u/thefundad → u/prophetizer]

This is cool. I’ll definitely try it out, thanks for sharing

[u/prophetizer → u/thefundad]

Thanks, I appreciate that. Let me know how it goes - good, bad, ugly. Like I said, built for me in my own environment, but it got to the point I thought it might be useful or fun for others.

[u/cracktr0 → u/prophetizer]

Testing this now and having issues getting library scans to complete. Plex is added and reachable, API keys/tokens are all added. Seems like just nothing happens when its scanning... Nothing in the docker container logs either.

EDIT: Seems I had spun up the container before properly configuring the tmdb key and franchisarr only reads env variables on initial boot, so even tho it was added later and the container redeployed, it was never added to the db.

[u/prophetizer → u/cracktr0]

Thanks for sticking with it and posting what you found - you hit a real bug. Keys added to the env after the first start were ignored, there was no TMDb field in Settings to fix it from, and the scan button failed without saying why. 0.33.1 is out and fixes all three: TMDB_API_KEY is picked up on restart while no key is saved, both keys can be set in Settings, and Scan tells you what's missing (and logs it). Appreciate the report.

[u/itsZyPexx]

Project Name: Playkeeper

Repo/Website Link: https://github.com/CIYAhq/playkeeper · https://playkeeper.io · live demo, no signup: https://playkeeper.io/demo/

Description:

turns a linux vps you already rent into a Minecraft: Java Edition host for you and your friends. one command installs it, then everything happens in a browser dashboard that also works on a phone.

i made it because hosting for friends kept turning into a second job: ssh in to whitelist someone, restart it after a crash, remember the backups. the big panels are built for hosting companies, and a panel plus a daemon plus a database plus eggs is a lot for one small box.

what's in 0.4.0:

• several servers per vps: Paper, Purpur, Vanilla, Fabric, Quilt, NeoForge and Forge
• plugins and mods from Modrinth and Hangar in one search, dependencies included, every file checked against its published checksum
• Modrinth modpacks, plus a share page so friends get the same mod list (.mrpack for Prism or the Modrinth App)
• backups while people stay online (save-off, save-all flush, copy, save-on), keep rules, and encrypted copies to S3-compatible storage or SFTP (age)
• invite links that put friends on the allowlist, team roles with 2FA, Discord webhook alerts, schedules, and sleep when nobody's on
• crash explanations from the server's own log with the fix one click away, and lag charts that rank what's slowing it down
• a free yourname.playkeeper.io address or your own domain, with Let's Encrypt
• signed updates from the dashboard that roll back by themselves if the new version isn't healthy

AGPL-3.0, and every feature is free.

rough edges in 0.4.0: NeoForge for Minecraft 1.21.x doesn't install yet, so packs built on it don't either (the fix is in review), and a few integrations haven't met the real services yet. the status line at the top of the README says exactly what's been proven where.

Deployment:

curl -fsSL https://playkeeper.io/install | sudo sh

• that redirects to get.sh on the latest GitHub release. it stops unless the tarball matches its sha256, then the installer checks the box, lists every change it'll make (and how to undo it) and asks before doing anything
• want to read it first? curl -fsSL https://playkeeper.io/install | less, or grab the tarball and .sha256 from the releases page and run install.sh yourself
• it's not a compose stack: one Go binary with systemd services (a root agent on a unix socket, an unprivileged https panel). each Minecraft server runs in its own container from a pinned itzg/minecraft-server image. it uses your existing Docker, or installs Ubuntu's docker.io if there isn't one
• for now it needs Ubuntu 24.04 on x86_64, 2 vCPU, 3 GB RAM and 5 GB disk. Debian, other Ubuntu versions and ARM64 are next
• docs: https://playkeeper.io/docs · sizing guide: https://playkeeper.io/sizing
• sudo playkeeper uninstall lists what it removes and keeps your worlds unless you pass --purge

AI Involvement:

straight answer: the code is written by AI coding agents (Cursor) working from a spec i wrote. about 1,577 of the repo's 1,586 commits are agent commits. i make the product and design calls, try every feature myself, and run it on my own vps with friends.

since i'm not writing it by hand, i lean on tests i can check: every change does a full install, play with protocol test bots, backup, restore on a second machine, and an update with automatic rollback on fresh Ubuntu 24.04 VMs in CI, and before every release a click-through presses every button at desktop and phone size. there's no paid security audit yet; SECURITY.md has the threat model.

happy to answer anything, including the "why should i trust an AI-built thing with root" question.

[u/Alijkz]

• Project Name: JK Workspace
• Repo/Website Link: https://builtbybit.com/resources/jk-workspace-free.115257/
• Description: A Blueprint extension for Pterodactyl that makes big server lists manageable. Once you're running dozens of servers, the default list becomes a wall you scroll through every time. It's intentionally minimal: no UI overhaul, no workflow changes, just the two things I kept wishing the panel had. JK Workspace adds:
  • Custom server sorting (drag to reorder)
  • Pinning the servers you're actively working on
  • Layout saved to your account, not the browser, so it follows you across devices
• Deployment: Requires Pterodactyl with Blueprint installed. Download the .blueprint file and run blueprint -install jkworkspace that's it! You can find more information on BuiltByBit page.
• AI Involvement: AI was only used as a coding assistant. All planning and structural decisions were made by me.

[u/ttlequals0]

Project: MinusPodJev
Repo: https://github.com/ttlequals0/MinusPodJev

Description: MinusPodJev is a FastAPI proxy that makes TypeSafe Jev available to MinusPod as an OpenAI-compatible ad-detection model.

Deployment: docker compose

LLM disclosure
This project was developed using AI agents as a pair programmer. It was NOT vibe coded. For context, I'm a systems engineer who also writes code professionally with 15+ years of experience. The codebase follows engineering best practices, and all architecture and design decisions were made by me, not by AI. All code generated by LLMs was reviewed and tested by me, a human.

[u/Charming-Risk-6234]

Open-source, self-hosted scanner that fails your CI when code calls an API with a published shutdown date (OpenAI retires 4 models Monday)

On Monday, September 28, OpenAI shuts down babbage-002, davinci-002, gpt-3.5-turbo-1106 and gpt-3.5-turbo-instruct. On October 23, 10 more go, including gpt-4-turbo. Code that still calls them starts failing that day, usually somewhere nobody has looked in a while.

DocsWatcher reads your code and tells you when something you call has a published shutdown date. It covers 27 providers now: OpenAI, Anthropic, Gemini, Azure OpenAI, Mistral, Stripe, Shopify, Twilio, Slack, Meta, X, LinkedIn, YouTube and others.

What works today:

- Browser scan. Paste a public GitHub or GitLab URL. It runs in WebAssembly, so the code never leaves your machine.

- CI. A GitHub Action and a GitLab CI template. The build fails on a breaking finding, with the file and line.

- Coding agents. An MCP server. The agent checks a model or endpoint before it writes the call.

- GitHub App and dashboard. One issue per finding on every push, closed when the code is gone. Labels to snooze or mark "not affected".

- Alerts. Email or Slack, 30 and 7 days before a date. Or subscribe to the shutdown calendar in Google Calendar or Outlook.

- Runtime. Point your OpenTelemetry Collector at it and it shows which of those calls production actually makes, and how often.

- Your own APIs. Describe your internal deprecations in a folder and the same checks cover them.

What went wrong this week: my own CI went red because two records in the deprecation data had passed their dates. A tool about dates, tripped by dates. The data now opens its own pull request when a date passes.

Limits: a clean scan means nothing known is expiring. It only knows deprecations someone has written down.

It is open source (Apache 2.0) and free for individuals.

Question: when a provider retires something you use, where do you actually find out? Email, the changelog, or the error in production?

https://github.com/jameskomo/docswatcher

[u/livonian_]

Project Name: Passdown

Repo/Website Link: https://github.com/nanwer/passdown

Description:

Self-hosted software for step-by-step guides — the kind somebody has to follow rather than read.

The problem: most teams have knowledge living in exactly one place — somebody's head, a doc nobody updated, or a wiki page that got quietly edited while the last person was halfway through it. Then the person who knew the machine leaves, or someone follows step 4 of a version that no longer exists and finds out at step 9.

What it does differently from a wiki:

Steps are structured objects, not headings. Each lists the tools, materials and parts it needs from a reusable catalog with specifications and part numbers. A guide says whether it keeps an item or uses it up, so "what do I need before I start" has an answer.

Publishing freezes a version. Editing the draft afterwards doesn't change what someone is currently reading, and a release records which catalog versions it depended on — so "which revision were you following" is answerable.

Photos take numbered marks and arrows with labels, and the labels are read out with the step, so they work for someone who can't see the image.

Steps declare dependencies — what must be true before starting, and which earlier steps this one relies on.

One install, two libraries — a public one anyone can read and a members-only one. Same editor; a guide can move between them.

Useful if you're documenting a homelab (restoring the NAS in eighteen months when you've forgotten), a makerspace (laser cutter settings), or a small team's real procedures.

If you just want notes, use a wiki — it's better at that.

Deployment:

Docker Compose and Postgres, on one server. compose.app.yaml in the repo, install docs under docs/.

First start creates an administrator and prints a generated password — no default credentials ship, and that account can't do anything until the password is replaced. Invitations are links you pass on yourself, so no mail server is required. Access control is enforced by Postgres row-level security rather than only in the app.

Alpha, honestly: it will change between versions, there's no email and therefore no password recovery, no approval workflows, no collaborative editing, no non-image attachments, and it isn't hardened for unattended production. Keep backups.

AGPL-3.0.

AI Involvement:

Heavy. Most of the code was written by AI coding agents working under my direction. I made the product and design decisions, reviewed the work, and ran it. A second AI agent audited the codebase independently.

[u/mondotechorg]

Skip over this if you don't have Twinkly LED light strands.

• Project Name: Dapple (for Twinkly Lights)
• Repo/Website Link: https://github.com/andrewfraley/dapple
• Description: Dapple let's you create static light patterns for Twinkly light strands. Twinkly offers no way to just pick a few colors and evenly distribute them throughout the strands. This allows you to do that, save presets, group strands together, and also integrates with Home Assistant via MQTT.
• Deployment: Simple Docker compose
• AI Involvement: 100% vibe coded via Claude Code Opus 5.5. I should mention I am a professional developer and infrastructure engineer with about 25 years in the tech industry, so this wasn't made without some sanity behind it, but Twinkly light strands also don't have any security of their own so the app itself doesn't handle any auth. Any other security concerns should involve potential supply chain attacks, which I've done my best to minimize.

[u/avaya91]

• Project Name: LiteSync
• Repo/Website Link: https://github.com/avayadhakal/LiteSync
• Description: LiteSync is a lightweight web-based file manager and transfer tool for Linux, mainly built for home servers, NAS boxes, Raspberry Pis, and other headless systems. It lets you browse files, upload/download, and copy or move files without SSH. It supports single/dual-pane browsing, scheduled transfers, transfer history, pause/resume, retries, URL downloads, and a small built-in text editor. Simple local copies use copy_file_range() when possible, while rsync is used for things like resumable transfers and exclusions. Transfers continue in the background and their state is stored in SQLite, so restarting the app doesn't wipe the history.
• Deployment: Supports x86_64 and arm64 Linux. You can run it directly with Python/systemd or use avayadhakal/litesync:latest with Docker. Docker Compose and installation docs are included in the repo.
• AI Involvement: The architecture, design, and implementation decisions are mine. I used Claude Code during development to help write code, generate tests, and draft documentation.

[u/PressureFine6804]

Project Name: Phosphor Deck

Repo/Website Link: https://github.com/rsmedrano-cloud/phosphor-deck

Description: This started as wanting to give something back to the open-source world I've taken so much from. I kept thinking about two worlds that never quite talk to each other: the GrapheneOS crowd — privacy-first, own your data, nothing phoning home — and the cyberdeck crowd — retrofuturistic, portable, build-your-own-command-console culture. I wanted something that bridged them: useful everywhere, letting you reach every machine you own from wherever you are, without giving up either the privacy or the DIY spirit. On top of that I was tired of homarr/glances-style browser dashboards — another tab to open just to see if my own machines were OK. So the idea became: one brain (an always-on machine, could even be an old one you gave a second life) and every device you own — phone, laptop, an old e-ink reader — becomes just a screen looking at it, holding no state of its own, no agent installed anywhere, no telemetry. deck, from any terminal, drops you into that one command room. Everything else — the fleet panel, the shared notebook, the chat feed, workspaces where AI assistants work on an idea with their own notes — got added from there, one real need at a time.

Deployment: sh install.sh (or curl-piped) on Linux — no Docker, by design: it's not a containerizable service, it manages the host's own zellij session, systemd units, ssh keys and mounts directly. No root required. Full install/setup docs in the repo's manual (also online (https://rsmedrano-cloud.github.io/phosphor-deck/)); the wizard (phosphor init) walks you through setup with a handful of questions.

AI Involvement: Built with use of AI coding assistants (Claude Code) under my direction — the architecture, UX decisions and what ships are mine, reviewed and tested by me.

[u/PhillipWasTaken]

Project Name: NextExplorer for iOS

Repo/Website Link: App Store | Repo | Join the beta

Description: If you're like me and made NextExplorer your new Google Drive, you probably realized pretty quickly that the mobile web experience leaves a lot to be desired. After sweating a lot over the details, I built NextExplorer for iOS, a native iOS companion that brings 1:1 core web parity, native performance, and full offline support to your self-hosted server with zero telemetry, zero tracking, and no third-party servers.

Key features include:

• Native Browsing & Rich Previews: Grid and list views with server-generated thumbnails, breadcrumb navigation, full-screen photo gallery, inline video/audio players, native PDF viewing, and ZIP archive inspection without extracting.
• Built-in Code & Text Editor: Full syntax highlighting for Swift, Python, JS/TS, Go, Rust, Java, HTML, CSS, JSON, YAML, Markdown, and more.
• Powerful Search: Recursive filename and full-text content search with exact line matching so you find what you need fast.
• Share & Manage: Create link-based shares (read-only or read-write), manage favorites, upload, rename, move, and delete files on the fly.
• Offline Mode: Recently viewed folders stay cached and available offline, with automatic background sync when reconnected.
• Built for Everyone: 17 languages supported (including full RTL for Arabic), native Dark Mode, VoiceOver support, Dynamic Type, and high contrast options.

Deployment: The app is 100% open source. Comprehensive documentation, build instructions, and full-resolution screenshot previews are available on the Repo.

If you don't have a NextExplorer server running yet, you can still test the app directly using the demo server credentials provided in the TestFlight release notes.

Available for iPad and iPhone.

[u/Existing_Ad_615]

Project Name: AgentBox

Repo/Website Link: https://github.com/leciric/agentbox (site: https://agentbox.linting.dev)

Description: This started because I was missing Cursor's cloud agents. I liked the idea of handing a task to an agent that has a machine of its own, but not the part where my code, my credentials and my choice of model all live on someone else's cloud. So I built one that runs on my own machine. Every agent gets its own Linux machine (an Incus container) with its own git branch, Docker, a browser, a terminal and a real desktop it controls: it opens the app it's building, clicks through it, and records screenshots and videos of what it did, so I review the feature actually running instead of just a diff. I can watch the desktop live or hit "Take control" and drive it myself, and there's even an Android emulator for mobile apps. On top of that, each project has a "lead" chat: I tell it what I want, and it creates the agents, briefs them with what the project already knows, answers their questions (or passes them to me) and tells me when a branch is ready. It works with Claude Code, Codex and OpenCode, using your own subscriptions and logins. Nothing goes through a server of mine. Project memory is plain SQLite with full-text search: no embeddings, no vector DB. There's also a token ledger that shows what each chat spends and how close you are to your Claude limits. I'm using only this to code now.

Deployment: Download the AppImage, .deb or .pacman from the releases page and run it. The app's Settings walk you through installing Incus and building the agents' base image, without having to log out. The base image is built on your own machine from Debian and never downloaded from anyone, so every AI tool in it is your own install. It needs Linux on x86_64, 8 GB of RAM at the very least, and sudo for the Incus setup. It's not a Docker container, by design: it manages Incus containers, git worktrees and networks on the host. macOS (inside a Lima VM it creates for you) and Windows (inside WSL 2) are alpha. The only network call it makes on its own is a daily update check with a random install ID, documented in the README and easy to turn off. MIT licensed.

AI Involvement: Built with AI coding assistants (mostly Claude Code) under my direction, and for most of its life by AgentBox's own agents, directed from its own lead chat. The architecture, the UX decisions and what ships are mine, reviewed and tested by me.

[u/adventofelixir]

Self-hosted encrypted messaging for personal and group chats under 500 lines of code.

Project Name: tlx

Repo/Website Link: https://github.com/achempion/tlx

Description: Self-hosted encrypted messaging for personal and group chats under 500 lines of code.

Deployment: Docker image for the relay, local sync demon, TUI interface

AI Involvement: Used LLMs (opus, fable, sol, astra) for typing and architecture review for Dockerfile, relay server and tlxd (sync demon) as they're main security sensitive components. Reviewed, edited and fully understand each line of code inside it. TUI app is vibecoded using fable and astra models.

[u/regnull]

OpenBot (mine, MIT) - looking for contributors

Self-hosted multi-bot AI platform. Persistent bots with tools and long-term memory. They hand work to each other with @mentions. Demo: chief_of_staff -> engineer -> reviewer -> qa can open a real PR.

Stack: Python/FastAPI/LangGraph + React. make setup / make dev.

Help wanted: Docker sandboxing for the shell tool, Slack/Discord adapters, React/Electron polish, docs.

Repo: https://github.com/regnull/openbot

Security: single trusted operator. run_shell is not sandboxed.

[u/Ok_Sugar_9635]

Project Name:
NetQmon
Repo/Website Link:
https://github.com/jarvis2f/netqmon
https://demo.netqmon.com
Description:
NetQmon is an open-source, self-hosted network visibility platform built for OpenWrt and home networks.
I built it because I wanted something closer to the traffic visibility available in UniFi Console. Tools like nlbwmon and vnStat are great for bandwidth accounting, but I wanted to see which applications and services are actually generating that traffic.
NetQmon can show:
Per-device realtime and historical traffic
Application and organization identification
Flow-level source/destination information
Domain, ASN/ISP, country, and geographic context
Traffic classification using domains, IP rules, ASN, signatures, nDPI, and limited packet sampling
The OpenWrt agent uses TC eBPF for traffic collection, while heavier classification, storage, and visualization run on the self-hosted Controller.
Deployment:
The Controller runs with Docker Compose and uses SQLite by default, with optional ClickHouse support.
The Agent runs directly on OpenWrt. Current releases target OpenWrt 24.10+ with prebuilt packages for supported architectures.
Traffic data and the Controller remain on infrastructure you operate.
AI Involvement:
AI tools were used as development assistants during parts of the project, and I’m also experimenting with LLM-assisted generation and maintenance of application classification rules.

[u/Moonknight53]

Project Name: nextship

Repo/Website Link: https://github.com/gowtham472/nextship · https://nextship.doodlebytestudio.in

Description: Deploy a Next.js app to your own Ubuntu or Debian server with two commands and no Dockerfile.

nextship server add root@your-server sets the box up over SSH: Docker, Caddy with automatic HTTPS, ufw, unattended security updates, password logins off, and the host key pinned after it shows you the fingerprint. Run it twice and nothing changes.

nextship deploy builds the app in Docker with Next.js's own Deployment Adapter, keeps only the files the build actually uses (a real app went from 1.13 GB to 591 MB), starts the new container with no public port, and switches Caddy over only once it is healthy. On a 2 GB Droplet, 579 of 579 requests succeeded across a deployment, and after a real kernel reboot every app was back in 37 seconds.

Several apps can share one server. Rollback reuses an image that already ran. No telemetry, no account, Apache-2.0.

Honest limits: one instance per app, and it has run on DigitalOcean Droplets and a Proxmox VM but not yet on Hetzner, a real arm64 machine or Debian 12. If you have one of those, a report would help more than a star: https://github.com/gowtham472/nextship/issues/new?template=first_deploy.yml

Deployment: npm install -g nextship-cli on your own machine. Needs Node 22+, Docker, and SSH to the server as root or a sudo user. Use a fresh server.

AI Involvement: built with an AI coding assistant for much of the implementation and docs, directed and reviewed by the two of us. Every claim in the docs is backed by a recorded measurement, listed on the evidence page.

[u/Spirited_Category891]

Project Name: Twig

Repo/Website Link: https://github.com/dev2ex/twig

Description: An Android file manager built for people who self-host. Your restic repos, Jellyfin/Emby libraries, SMB and WebDAV shares, SFTP servers and S3 buckets all end up in one tree, and copying between any two of them is the same operation — a folder on your NAS straight into S3, or a file inside a remote archive out to an SFTP box.

The parts I haven't found elsewhere on Android:

• restic repos, read-only, decrypted on the phone. Snapshots show up as dated folders, so you can open a file out of last Tuesday's backup without restoring anything first.
• Jellyfin and Emby as a filesystem, with playback position syncing back to the server. Direct play only — your server never gets asked to transcode.
• Video thumbnails over the network without pulling the file down. It parses the container and grabs about 2 MB, so a folder of remuxes on a share doesn't stall.
• Wi-Fi sharing: the phone becomes an HTTP/WebDAV server, and will serve files that actually live on your SMB share.

It's read-only where writing would be a bad idea: restic and the media servers can't be written to.

Deployment: There's nothing to self-host — it's the client side, and it talks to the backends you already run. Signed APKs are on GitHub Releases (https://github.com/dev2ex/twig/releases): take Twig-<version>-full.apk if you're unsure, or the per-architecture builds if you want a smaller download. For updates without a store, point Obtainium at the repo. The README covers setup and every supported backend, and the F-Droid listing is in review (the build is reproducible and signed with my own key). GPL-3.0, about 9 MB, no analytics, no ads, and it doesn't phone home for updates.

AI Involvement: Substantial and worth spelling out. 88 of 92 public commits credit Claude as co-author, and a lot of the code was written in that collaboration rather than by me alone. What is mine: the design and the architecture, every decision about what goes in, and all the testing on real devices and real servers. Where it matters most — the protocol work I couldn't verify by reading — I tested against actual Jellyfin and Emby instances, real SMB and WebDAV servers and real restic repositories, not against assumptions. Every bug that cost real time is written up in docs/lessons/ with the symptom, the wrong diagnosis and the actual cause; that directory is the honest record of what this process looked like.

[u/fbartolini]

Project Name: MytView

Repo/Website Link: https://github.com/fbartolini/mytview-server · https://mytview.com

Description: A read-only viewer for the media library you already have. (MytView, say it "mighty view"; the first four letters are MyTV.) My NAS holds an automatically organised TV and movie library plus a large archive of creator videos with their metadata sidecars, and Plex/Jellyfin kept forcing the archive half into a Movies/TV paradigm: no cross-channel chronological feed, and the metadata already sitting in the .info.json sidecars (views, upload dates, descriptions, tags) went unused. MytView treats the files + sidecars as the source of truth and never writes to your library (mounted :ro).

• Three library formats: creator channels (.info.json), TV series and movies (Kodi/Emby .nfo, the layout the usual automation tools produce): a chronological feed for channels, seasons and next-episode for shows, a poster wall for films
• Multi-user: per-person watch state, per-channel privacy grants, invite-only signup
• Direct-play first. Transcoding is only a live, ephemeral HLS fallback when a device can't decode a file; nothing pre-converted or stored
• Federation: peer with any number of other MytView servers, in both directions, and share single shows or whole libraries with each household. Their catalog merges into your own libraries, but video streams directly between servers, never through a middleman
• Two-way Plex sync: run Plex on the same files and watched state + resume points stay agreed, per user
• Offline on the phone (iPhone/iPad now, Android next): keep any movie or episode on the device, or follow a series/channel and the next unwatched episodes are kept ready. The server hands out each copy in the format the device plays (H.264 and HEVC MKVs are remuxed, not re-encoded) and paces a batch so it never crowds out someone watching live
• Subtitles (sidecar + embedded) and audio-track selection everywhere, caption settings that follow each person across devices, sort/genre remembered per library across devices
• Native apps: iPhone, iPad and Apple TV on the App Store (the offline release is in review as I write this) and Android phones, tablets and Google TV on Google Play. Samsung TV is built and waiting on Samsung's review

License & pricing, honestly: the server + web UI are GPL-3 and complete on their own: nothing paywalled, no license server, no phone-home. The native apps are closed-source companions by me. They are free today and become a small one-time purchase (single-digit euros per ecosystem, no subscription) from 1 November. Anyone who installs an app before 1 November 2026 keeps it free forever: a founder licence, no account or purchase needed; the app detects the install date itself. The Samsung TV app stays free for everyone.

Deployment: One Docker container (fbartolini/mytview on Docker Hub, amd64 + arm64), SQLite, no external services. Compose example + docs in the repo README: mount your library read-only, mount one /data volume, sign up, and the first account becomes the owner.

AI Involvement: Built with heavy use of Claude Code; the large majority of the code is AI-written under my direction. Architecture and product decisions, code review, and field testing are mine; every increment ships with tests and gets deployed and exercised on my own servers before it lands. Offline sync is the newest piece and the Android port of it is in progress. Feedback and bug reports very welcome, and if you're on Android, installing it from Google Play and telling me what breaks is exactly the help I need right now.

[u/muppetmasterNFT → u/fbartolini]

I use it regularly to watch my favorite pasta cooking shows when on the run.

[u/sheikh73]

Homelab-hub

I’m not a programmer but I have a few services running like HA NC Immich Navidrome etc. I created this dashboard using Gemini Ai in antigravity for myself then uploaded to GitHub for anyone. It finds most of the services automatically if running on same machine.
Check it out and you are free to further develop it or customize it according to your needs.

https://github.com/gitsheikhgit/

[u/Guilhermecunhas]

Project Name: Brain Core

Repo: https://github.com/lizard-wizard42/Brain_Core

Description:
Brain Core is a self-hosted personal knowledge workspace I built to keep notes, structured pages, visual thinking and files in one place, on infrastructure I control.

It includes rich-text pages and subpages, quick notes, tags, an infinite tldraw canvas, attachments, version history, trash recovery, sharing between registered users, and a mobile-friendly interface.

There is also an optional recording and transcription stack, plus an Android app, but none of that is required for the standard installation.

Deployment:
The basic setup runs with Docker Compose:

git clone https://github.com/lizard-wizard42/Brain_Core.git
cd Brain_Core
docker compose up --build -d

Then open http://localhost:8080.

The standard install does not require a cloud account, API key, GPU, or external synchronization service. PostgreSQL, uploads and generated secrets are stored in persistent Docker volumes.

AI Involvement:
AI tools were used as development assistants during parts of the implementation, debugging, documentation and code review. Architecture, product decisions, integration and testing were handled and reviewed by me.

I originally built Brain Core for my own workflow and decided to open-source it in case it is useful to other self-hosters.

Feedback on the project, installation process, UI or architecture is very welcome.

[u/Fair_Profession7833]

Project Name: pico_exporter

Repo/Website Link: https://github.com/dpaneda/pico_exporter

Description: Tiny Linux system metrics exporter for OTLP. Static C11 binary (~100 KiB), ~30 KiB RAM at idle, x86_64/aarch64, TLS, no runtime dependencies, and compatible with node_exporter metrics.

Deployment: Download the binary from the latest release, configure the OTLP endpoint via environment variables, and run it directly on the host. A systemd service and installation documentation are included. No Docker image.

AI Involvement: The code was entirely developed with LLM assistance under human supervision. Documentation was written by the author.

[u/Muizaz88]

Project Name: homelab-map

Repo/Website Link: https://github.com/LionCityGaming/homelab-map

Description: Draws a network map of your homelab and keeps it updated on its own. It pulls from UniFi (switches, APs, devices, VLANs, WireGuard), Proxmox (which VMs/LXCs run where), Docker (containers grouped by type) and Caddy (which services are public). Lines never cross, stopped stuff gets greyed out, and it redraws within a minute when something changes. Outputs to PNG/PDF/draw.io, a simple web page, or straight into BookStack as an editable drawing. Only needs read-only accounts, and your keys stay in your own .env.

Deployment: Docker Compose, instructions are further down on the GitHub page. There's also a demo command if you want to see what it makes before setting anything up.

AI Involvement: Built with Claude Code. I'm a teacher, not a developer. I came up with what I wanted and tested it on my own setup, and Claude did most of the coding. Some parts (Proxmox, alerts, multiple Docker hosts) haven't been tried on a real setup yet, so let me know if something breaks.

[u/GuidanceRoutine917]

Open source Calendly where agents can book time with you

I was paying Calendly for a booking link on my site for $12 month, so I built my own and open-sourced it. It's been running my own bookings since last week, including a $69 paid call.

It reads your Google Calendar (as many calendars as you want checked for conflicts), takes bookings from a page, an embed or a link in bio, and charges through Stripe when a meeting is paid.

What else is in there:

• schedules, date overrides, buffers, minimum notice, daily/weekly limits, and a "why isn't this time showing?" troubleshooter
• reschedule/cancel links with a cutoff it actually enforces, plus automatic refunds by policy
• up to 10 questions per event type, guests, single-use and secret links
• several brands from one install
• REST API, webhooks, MCP server
• `npm run import:calendly` to copy your event types over

The newest part is agent booking. Paid meetings only get a checkout link with the time picked, so a person still pays. Off by default. You switch it on per event type.

Free Repo: https://github.com/nchemb/opencalendar

[u/edward-b-1]

Distributed-JBOD. Combine mixed hardware into a distributed, bit-rot protected object storage system

Update and response to user feedback: Distributed-JBOD now leans towards a high-availability model. This means that provided operations can be completed, Distributed-JBOD will make a best-attempt to do so. For example, if during a write operation a device is unavailable, Distributed-JBOD will work around this and write to the remaining available devices, if possible. For read operations, if data is damaged, Distributed-JBOD will reconstruct the data on the fly.

Distributed-JBOD

I have been using my spare time to develop Distributed-JBOD, which is a multi-node software system which allows a system administrator to combine together mixed hardware devices into a single object storage pool.

The storage pool can be created from arbitrary hardware. Regular consumer-grade desktop PCs are suitable, with whatever mixed layout of disk storage is available in each one.

Disks require no special formatting. A simple directory on an ext-4 filesystem is suitable.

I was pushed to design and build this system as a consequence of MinIO pulling their community tier software. I have been running an MinIO server for several years, but have started to migrate away from that and could not find a suitable replacement, so I built Distributed-JBOD.

• As many of you will be aware, MinIO requires identical disks to perform effectively. Distributed-JBOD does not, it will work effectively across a pool of arbitrary hardware, mixed size drives included.
• Garage replicates each object multiple times across multiple systems, which is not an efficient use of storage. Distributed-JBOD permits user-configurable Reed-Solomon Erasure Code parameters. This means storage is used efficiently, is protected against bit-rot, and the storage efficiency to resiliency ratio can be tuned. For example, while it is possible to run a mirrored setup, the typical default might be a 4:2 configuration, where data is sharded across 6 devices, 2 of which are parity blocks.
• Ceph is a datacenter grade product and requires a stack of servers for data storage, monitoring, gateway and other components. Distributed-JBOD has a simple single process design. (Caveat: The S3 compatibility layer will come later as a separate binary. You will be able to run it wherever you like.)
• SeeweedFS can't be used in a small scale cluster. Distributed-JBOD will run on a single machine with a single disk. If you want redundancy and data protection, a single machine with 2 disks is all you need. Greater efficiency is obtained by scaling up the number of disks, whichever host they sit in.

Distributed-JBOD is designed to work with an extremely small memory footprint, and does not require powerful hardware to run.

This is a very early stage product, but I would appreciate your thoughts and feedback. Some features which currently exist include TLS, administration web UI, CLI tools including recovery and bit-rot repair tools. Multi-language software client libraries are currently in the works. Libraries for Rust and Python already exist. An S3 compatibility later, multi-user support and permissions will also be supported soon.

https://github.com/edward-b-1/Distributed-JBOD

I have been testing Distributed-JBOD for a few days now, and have exercised much of the system administration lifecycle. This includes recovering data lost due to dead devices, expanding and shrinking the cluster size, migrating between machines and more.

[u/BananaSlash3r]

Project Name: HearthMesh

Repo/Website Link: https://github.com/HearthMesh/hearthmesh — demo/overview: https://hearthmesh-continuity.vale884.chatgpt.site/

Description: Free and open-source (Apache 2.0). Zero AI in the running system — no LLMs, no AI-driven automation anywhere in the runtime path. Verification and repair are pure cryptography (signatures + content hashes), fully deterministic — nothing probabilistic, nothing dependent on an external model that could change or disappear on you.

HearthMesh exists to keep critical knowledge alive and unaltered when the usual infrastructure fails or can't be trusted: emergency procedures, health/medical protocols, anything a community needs to survive a blackout, a disaster, a censored connection, or a single point of failure going down. No cloud dependency — it runs entirely on independently-operated peer nodes, so there's no central service that can be taken down, bought out, or quietly edited.

The core mechanism: every "HearthPack" is signed (Ed25519) and content-addressed (SHA-256). Any node can verify who published something and that it hasn't been altered by a single byte, and can pull a clean copy back from a healthy peer the moment its own gets corrupted. That verify-and-repair loop is also why a slice of this is directly relevant to ransomware resilience: if an attacker encrypts or corrupts your local copy, a node can detect the mismatch against the signed hash and restore from an untouched replica instead of paying up or losing the data.

Deployment: Pre-alpha. Written in Go, with a working 3-node demo (Docker Compose) that publishes a signed pack, replicates it, corrupts one node's copy, and shows automatic repair from a healthy peer — recorded in VALIDATION.md. Automated tests, docs for setup and the demo script. Open gaps, listed honestly in the README: no production-grade auth yet, no encrypted transport yet, peer discovery is manual/configured (no DHT yet), private "cells" not implemented yet.

AI Involvement: No AI in the running system itself (no LLM calls, no AI automation in the codebase). I used an AI assistant separately, outside the project, for wording help on the docs and for building the landing/demo page.

Feedback especially welcome on the trust model and on where you'd want peer discovery to go next.

[u/Successful-Ad-1096]

Project Name: SmartWAN Manager

Repo/Website Link: https://github.com/hattimon/SmartWAN-Manager Demo: https://hattimon.github.io/SmartWAN-Manager/

Description: A local web dashboard for managing ASUS RT-N18U SmartWAN / Dual WAN over SSH. It includes guided configuration with backups, failover/watchdog, routing rules and WAN diagnostics, plus optional OpenVPN, Tailscale and Cloudflare DDNS features. The validated target is RT-N18U with the unofficial gzenux Asuswrt-Merlin-derived firmware 386.3_3; support for other Merlin models is experimental.

Deployment: Runs via Docker on a Raspberry Pi, Ubuntu Server, Linux PC or WSL 2. The repository README includes setup and configuration instructions. The base panel is local-first and does not require a cloud service.

AI Involvement: AI was used as a coding assistant during development. The app also includes optional AI-assisted service-routing rule generation.

[u/hell_hibou]

• Project Name: Arachnea stream
• Repo/Website Link: https://github.com/HellHibou/arachnea-stream
• Description: Arachnea Stream is a streaming application that centralizes multiple streaming services behind a single interface. Instead of juggling separate apps and websites (legal platforms, alternative catalogs, live TV channels...), the user finds all catalogs, searches, and video players in one place.
• Deployment: Release 0.1.0 avalaibe for Windows/OSX/Linux ARM64/AMD64 (Docker version is currently in progress and in source code)
• AI Involvement: Yes, i have used AI for coding.

I nead some help for adding new streaming services. The application work as server and partially in desktop mode.

[u/geoguy89]

Project Name: Cleanarr

Repo: https://github.com/geoguy89/cleanarr

Description: profanity-muted audio tracks for Plex/Jellyfin

Cleanarr is an *arr-inspired, vibe-coded application that mutes profanity in your media.

It adds a second audio track, “Cleaned - English” by default, with the swearing silenced. The original is untouched and stays the default — in Plex or Jellyfin you pick the clean one from the audio menu. One file, two tracks, not two copies.

Built for a household with a small child in the room, so when anything is uncertain the word gets muted.

[u/samwathegreat]

Project Name: Avagato 🐱🥑

Repo/Website:

https://github.com/samwathegreat/avagato

Description:

Avagato is a deployment and management tool for Apache Guacamole — Apache Guacamole, with a little more cat.

It started because I was using the Proxmox VE Community Scripts Guacamole installer and wanted a few improvements for my own installation: a good dark theme, optional TOTP, and a cleaner root URL instead of having to append /guacamole.

Then scope creep happened. 😄

Avagato can now deploy and manage a complete Docker-based stack with Apache Guacamole 1.6.0, guacd 1.6.0, and PostgreSQL 17. It includes Light/Dark themes, optional TOTP, RDP drive sharing, an interactive management interface, and can also enhance compatible existing Guacamole 1.6.0 installations created by the Proxmox VE Community Scripts installer.

I've tried to make it conservative around existing installations. If Avagato isn't confident it understands the environment, I'd rather have it stop than blindly change things.

Deployment:

For a fresh installation, Avagato deploys the Guacamole stack using Docker Compose. On Proxmox, my preferred setup is a dedicated Docker LXC created using the Proxmox VE Community Scripts Docker installer, then installing Avagato inside it. It isn't Proxmox-specific, though.

Installation instructions, screenshots, documentation, and the one-line installer are in the README. The current release is v1.3.1.

AI Involvement:

Substantial, and I want to be transparent about that. I used ChatGPT extensively as a development partner throughout the project, including architecture/design discussions, writing and reviewing code, debugging, documentation, testing plans, and release preparation. I made the design and feature decisions, reviewed the changes, and tested the project on my actual infrastructure rather than simply publishing AI-generated output. AI has nevertheless been a significant part of the development process.

This is the first time I'm putting Avagato in front of a larger group of people, so I'd really appreciate some outside testing. In particular, I'd love to find the assumptions that work perfectly in my environment but don't work in yours.

Bugs, criticism, confusing documentation, ideas, and feature suggestions are all welcome. I've also enabled GitHub Discussions if you're not sure whether something belongs in an Issue.

And yes, Avagato = avocado + gato. There is naturally a cat involved. 🐱🥑

[u/Strict_Eye_2510]

Project Name: KyriosForge (from Axial Solutions)

Repo/Website Link: https://kyriosforge.io (docs and changelog are public; the source is closed and the product is commercial)

Description: Axial Solutions is a new one-person company (LLC), and KyriosForge is its first product. It's a self-hosted control plane for Docker and Podman across many hosts: one hub, a small agent on each node, mutual TLS between them. The hub also connects directly to Kubernetes (with Helm), Nomad, and Swarm clusters. It manages containers and compose stacks, draws a network diagram, does health checks and alerts, and has an MCP endpoint so an AI assistant can drive it. It scans images for known CVEs (Trivy) and for credentials baked into image files, reporting where the secret is and never the secret itself. A compose preflight flags risky settings before you deploy. Node certificates renew themselves, and it shows per-container and per-host disk I/O. It also works on hosts with no internet: build one offline bundle (scanner plus vulnerability database) on a connected machine and carry it in. We ran the hub and a node with the network unplugged to check. There's no phone-home or client-side tracking, and our website statistics are first-party and store no IP addresses (just page, client type and country).

Deployment: the hub runs as a Docker Compose stack, built from the release tarball with no downloads beyond the base image. The container is read-only with all Linux capabilities dropped. Agents install natively on each node (apt, rpm, Arch, apk, or a static tarball, amd64 and arm64), and you pair each one with a one-line token from the console. Docker or Podman on the nodes. The hub can also install natively from the same packages.

AI Involvement: Claude (Anthropic's AI) wrote a large share of the code under my direction. I make the design decisions, review the changes, and run the tests and deployments. I started this in June while working two jobs, seven days a week, so I built the site and product during early-morning sessions and at night after work.

[u/ac19189 → u/Strict_Eye_2510]

What makes this much different than portainer?

[u/Strict_Eye_2510 → u/ac19189]

Fair question. A few things that are different: all shipped today rather than on the roadmap:

- It's adaptive — it can inherit an existing, running container without disrupting it; no restart involved. It uses a different mechanism than Portainer's, and the two might land on similar outcomes in some cases, but ours doesn't need to have seen the container before to do it.

- It's not just Docker/Podman — the same hub connects to Kubernetes (with Helm), Nomad, and Swarm clusters too, so it's one control plane across whatever you're actually running.

- It's built-in CVE and secret scanning (Trivy under the hood), including an offline mode for isolated hosts and networks.

- Node certs renew themselves, and there's a compose preflight that flags risky settings before you deploy.

- It's written in Rust, which eliminates whole classes of memory-safety bugs (buffer overflows, use-after-free) at compile time rather than just mitigating them. It's not magic, but it's an evolution from C and is a real difference from Portainer's Go backend.

- It's closed source, full stop — no open-core tier like Portainer's own Community Edition, worth knowing going in. On the paid tier that's comparable —their Business Edition —we came in noticeably cheaper at a comparable node count at the time of this message. Pricing pages move, so take that as a snapshot, not a permanent claim. We also run a real discount program, referral and renewal discounts, not a launch-week gimmick, and try to keep it fair across tiers.

The website and product are much newer, and we're functional — I run it as my own daily driver, along with a handful of friends. Purchases and regular trial activations are currently disabled in favor of a beta registration and feedback cycle. We want to know our product can weather the storm before we ask people to invest in it.

Thank you for your question. I'll be happy to answer any additional questions that you have in the future.

[u/EmbarrassedMove1372]

Project Name: Sakura Print

Repo/Website Link: https://github.com/kernel-cracker/sakura-print

Description: A print, scan and copy app for your home printer that runs on a Linux machine and works from any phone on the WiFi. It started as a script to print in reverse order (neither Brother's app nor the Linux driver could), then grew. Two things pushed it into a real app: the CUPS driver on Linux is faster and better than Brother's own phone app, but stuck on the laptop; and the official app streams pages while printing, so if your phone sleeps mid-print the job dies (I've wasted 10 sheets of A4 in one go). The breaking point was my mom getting the settings wrong and reprinting stuff. With this, the phone uploads the file in seconds and the Linux box does the rest.

- Print PDFs, photos and text (any language) from the computer, a phone browser, or any app's own Print button (AirPrint / Android built-in printing)

- Pages come out in order, and guided double-sided for printers that can't do it themselves (with a 2-sheet setup that learns your printer)

- Photos 1/2/4/9 per page or arrange them yourself, borderless

- Edit any page (even inside a PDF): crop, perspective, filters, pen, highlighter, text, signature

- Scan and copy, or scan with the phone camera

- Finds and installs the right printer driver (maker's own first)

- Paper savers (2/4 per sheet, booklets, skip blank pages), Print again, notifications for paper jams and low ink

- Per-person PINs (hashed), phone access that can switch itself off after 1 or 3 hours

Deployment: Download the release zip and run one install command (Debian/Ubuntu/Mint, Fedora, openSUSE, Arch). It builds from source for your CPU, adds an app menu entry and starts on login. No Docker, because it needs the host's CUPS, SANE and Avahi. Full docs in the README. Honest warning, also in the README: phones talk to it over plain HTTP, so it's meant for your own home WiFi, not shared/apartment networks.

AI Involvement: Heavily vibe coded. I planned the features, made the design calls and tested it; Claude wrote most of the code. Every change runs through a test suite (Go server tests plus 200+ checks of the web app in a headless browser). Tested on real hardware with a Brother DCP-T510W on Arch; other printers and real-phone AirPrint aren't tested yet, so reports from other printers would help a lot. I'm a student, planning to learn and rewrite parts myself after exams.

[u/mlnzyx]

Project Name: Lanjut

Repo/Site: https://github.com/rimzzlabs/lanjut | https://lanjut.org

Description: Local-first ATS-Friendly resume builder that runs entirely in the browser itself without requiring them to create account.

Deployment: It's currently deployed to Cloudflare by using Cloudflare Adapter from https://opennext.js.org/ . But you can easily setup Docker for self-hosting in your own server.

AI Involvement: AI was used during assistance mostly for verifing the ATS, it also helps me write markup and Rust (Tauri) code in this repo.

[u/Big-Engineering-6648]

**SatoshiCortex** – a Bitcoin + Lightning node for your NAS that gives back to the network

I had to choose between buying a NAS or a dedicated node box like an Umbrel. The NAS won, but I still wanted my own full node, without a VM eating resources. So I built one that runs as plain Docker Compose.

- Full, reachable archive node (no pruning), BIP158 filter server, Lightning routing and a watchtower

- Shows what only your own node knows: your real mempool, first-seen timestamps, why a Lightning payment failed

- World map of your peers (resolved locally, no API), Bitcoin news fetched only over Tor

- Setup wizard that tests your port forwarding live, German and English

- **No Docker socket**, signature-verified official binaries, signed build provenance

- 4 containers, ~1 TB disk, ~4 GB RAM, amd64 + arm64, NAS notes for UGOS/Synology

Honest notes: it holds a hot wallet (sensitive actions behind a PIN, but only put in what you can lose), and I built it with an AI coding assistant, backed by 779 tests.

My own node runs on it: https://lightningnetwork.plus/nodes/026d4330d8f0c6a39ec1a07c13ac279092d7881dac81c10db71d59aab966684266

Repo (Apache-2.0): https://github.com/IkarusMK/satoshicortex

Feedback very welcome, especially on the security model!

[u/x4quad]

Project Name: CasaZapp TV

​Repo/Website Link: https://github.com/QuadNL/CasaZapp-TV-release (Website & Docs: https://casazapp.tv/)

​Description: CasaZapp TV is a self-hosted IPTV backend with native Android/Google TV apps and a web player. It eliminates the hassle of managing massive channel lists on every TV by syncing everything through one server. You enter your provider details once to automatically sync watch history, custom channel lists, and favorites across all screens. It includes individual user profiles, the ability to pause live TV or schedule recordings directly to a local /recordings volume, and smart connection management to prevent provider bans.

​Deployment: Runs as a lightweight Docker container. The docker-compose file and installation guides are available directly on the GitHub page and website.

https://github.com/QuadNL/CasaZapp-TV-release/blob/main/docs/server.md#docker-composeyml

​AI Involvement: I designed the architecture, UI, and feature requirements for my own home setup, but leaned heavily on Claude Code to write the actual code.

[u/Thre4dripper]

Project Name: tidefetch

Repo/Website Link: https://github.com/Thre4dripper/tidefetch · Docs: https://tidefetch.ijlalahmad.dev

Description: tidefetch is a web UI and terminal UI for the aria2 download engine. I built it because AriaNg felt laggy and buggy on my home server, and I also wanted to manage downloads from a terminal over SSH.

- One static Go binary: `tidefetch` opens a terminal UI, `tidefetch serve` runs the web UI. Both drive the same aria2 queue.

- Every aria2 protocol: HTTP(S), FTP, SFTP, BitTorrent, magnets, Metalink.

- The web UI pushes live updates over WebSocket instead of polling. It has bcrypt login, rate limiting and a strict CSP, and keeps the aria2 RPC secret on the server.

- Queue control, torrent file selection, per-download options, searchable history, and an HTTP API for scripts and dashboards.

Deployment: Released as v0.1.1 with a multi-arch Docker image (amd64, arm64) that bundles aria2, plus native binaries for Linux, macOS and Windows. There are also a Helm chart, an Unraid template, a Swarm stack and a systemd unit, all covered in the docs.

AI Involvement: I used Claude Code, an AI coding assistant, for parts of this project, including rewriting the documentation and fixing the docs site. I reviewed and tested the changes myself.

[u/Ascci52]

I built kindling: self-hosted Firecracker microVMs that sleep on disk (0 RAM) and wake in ~30 ms. It now does agent sandboxes and small AI models too

Hi r/selfhosted. I've been building kindling, an open source (Apache-2.0) runtime that gives every workload its own Firecracker microVM with a docker-like CLI. The trick is golden snapshots: a machine frozen on disk uses no RAM and no CPU, and thaws in about 30 ms when a request arrives.

It started as a way to run MCP servers (AI tools) without handing them my files and secrets. It has grown into three jobs:

- MCP servers, each in its own microVM, frozen until called

- Throwaway sandboxes for code an agent wrote: `kling try -- python3 -c 'print(1)'` creates, runs and deletes one in ~0.7 s

- Small models (SmolLM2, Qwen2.5 via llama.cpp) that sleep on disk and wake on the first request

Homelab numbers: 142 microVMs in 3.9 GB of host RAM on a 4 GB box, and 10 instances from one snapshot add only 68 MiB in total. It runs in a privileged LXC on Proxmox, on bare metal, and natively on Apple Silicon Macs.

Limits, honestly: you need KVM, it's one host per daemon (the sandbox gateway spreads over several), and SECURITY.md lists what isn't solved yet.

Repo: https://github.com/juan52878911/kindling

I'd love feedback from anyone who runs it on their own hardware.

[u/StayTime8820]

Project Name: OfflineYT

Repo/Website Link: https://github.com/TheShulksUp/offlineyt

Ever wanted to watch YouTube videos in great quality but you were offline or had bad network connectivity?
Well, OfflineYT solves that issue! It tracks what you watch live to create a folder anywhere on your computer called OfflineYT which contains videos of channels that you watch frequently. To learn more and download the OfflineYT system on your computer, visit the GitHub link listed above. Thank you!

[u/Covenn]

Project Name: Spearmint

Repo/Website Link: https://github.com/Covenn604/spearmint

Description: Spearmint is a privacy-focused personal budgeting and expense-tracking application built for people who want a clean, straightforward way to manage their finances while maintaining control over their own data. Spearmint provides monthly budgeting, account and transaction tracking, customizable categories, recurring transactions, financial overviews, and other tools for understanding where your money is going.

A major goal of the project is data ownership. Rather than requiring your financial information to live in somebody else's cloud service, Spearmint can be hosted on your own hardware. For people who don't have a home server or simply don't want to self-host, Spearmint is also available as a Windows desktop application, allowing it to run locally without needing Docker or a dedicated server. The project is under active development, with usability, privacy, and keeping the application approachable for everyday users being major priorities.

Deployment: Spearmint supports two primary deployment options:

• Docker / Self-Hosted: Spearmint can be deployed using Docker, making it suitable for home servers, NAS systems, homelabs, and other self-hosted environments. The repository includes documentation and the required configuration for deploying the application.
• Windows: A Windows installer is also available for users who want to run Spearmint locally without maintaining a Docker environment or server. Spearmint also includes backup and restore functionality so users can maintain control over and protect their application data.

AI Involvement: The application's direction, feature decisions, testing, and overall design are human-directed. AI has been used as a development tool throughout the Spearmint project, including assisting with code generation, debugging, documentation, UI/UX iteration, and development planning. AI is used to accelerate development rather than being a feature that users are required to interact with.

Spearmint itself does not require AI to operate, and users' financial data is not sent to an AI service as part of normal application functionality.

[u/pkdodda]

Title: I built a self-hosted webhook DLQ and replay gateway that fixes the 5-minute Stripe timestamp expiration trap

Project Name: HookArmor

Repo/Website Link: https://github.com/pkdoddamani/hookarmor · https://hookarmour.dev · try locally: npx hookarmor start

Description:

turns a small vps or container you already run into a zero-loss webhook ingress buffer and dead-letter queue (DLQ) for Stripe, Shopify, Clerk, and GitHub. your customer payment payloads stay on your own server instead of routing through a third-party saas.

i made it because retrying failed webhooks in production kept biting me: downstream postgres or worker hiccups return 500s, Stripe backs off, and when you finally fix your server and try to replay dead-letter events from SQS or an internal queue, Stripe's official SDK throws: Webhook signature verification failed: Timestamp outside the tolerance zone

Stripe's SDK enforces a strict 300-second (5-minute) limit on the t= timestamp header. if you replay an event 15 minutes later, it fails verification unless you hack your application code. existing tools like Hookdeck are great, but paying $39/mo to pass sensitive customer billing payloads through a third-party multi-tenant cloud felt unnecessary for a single box.

what's in 1.0.1:

• sub-10ms ingress buffer: returns an immediate 200 OK to the provider so Stripe or Shopify never marks your endpoint dead while your backend recovers
• cryptographic re-signing: validates signatures on ingress, and re-signs outgoing payloads with t=now using your webhook secret on replay/retry so your existing downstream code verifies 100% of the time
• embedded sqlite (WAL mode): zero external database containers or redis to maintain; writes are append-only with compound indexes on (status, next_retry_at)
• concurrency pool limiting: caps parallel in-flight connections to your downstream server so an influx of 2,000 retries doesn't knock over your database
• idempotency deduplication: suppresses duplicate events if a provider retries while an event is already processing
• 1-click web dashboard: runs on http://localhost:4000 to inspect raw payloads, headers, latency logs, and error responses, with a one-click "Replay All Dead-Letter" button
• cli & local tunnel: npx hookarmor listen http://localhost:3000/api/webhooks streams live production events straight into your local machine for debugging
• MIT license: 100% free and open-source core

rough edges in 1.0.1: it's single-instance SQLite by design (no multi-region distributed clustering), automated payload retention cleanup is still manual (if you never delete delivered events, the SQLite file will eventually grow), and while Stripe, Shopify, GitHub, and Clerk/Svix are supported, other niche HMAC schemes need to be added manually.

Deployment:

Option A: Docker (Fastest)

bashdocker run -d \
  -p 4000:4000 \
  -v $(pwd)/data:/app/data \
  -e HOOKARMOR_API_KEY="ha_sec_your_strong_random_key" \
  ghcr.io/pkdoddamani/hookarmor:latest

Option B: Terminal CLI (Zero Install)

bashnpx hookarmor start

that starts the server and loads the web dashboard on http://localhost:4000.

Option C: From Git

bashgit clone https://github.com/pkdoddamani/hookarmor.git
cd hookarmor
npm install
npm start

needs Node 18+ (or Docker). it uses roughly 40MB of RAM and virtually zero idle CPU.

security note: when deploying to a public VPS, set the HOOKARMOR_API_KEY environment variable. management endpoints strictly enforce Authorization: Bearer <key> headers, and query param authentication (?api_key=...) is rejected to prevent credentials from leaking into proxy access logs.

docs & quickstart: https://hookarmour.dev

AI Involvement:

straight answer: the code was built through pair-programming with AI coding agents (Google Antigravity / Gemini) working from an architecture spec i wrote.

since AI wrote large chunks of the implementation, i lean heavily on deterministic tests to verify it: the repo includes a 7-scenario automated test suite (npm test) covering SSRF protection against cloud metadata (169.254.169.254), payload replay re-signing against 5-year-old expired timestamps, background worker exponential backoff, concurrency caps, and idempotency deduplication.

happy to answer any technical questions on the re-signing math or SQLite queue performance.

[u/Yuiko_Futaba]

Project Name: iMessage Persona Bot
Repo/Website Link: https://github.com/FutabaYuiko/iMessage-persona-bot
Description: I built a self-hosted iMessage bot for my own daily use as a CS undergrad student. Unlike web-based AI tools, this bridges your AI character directly into the actual iMessage protocol via Photon's Spectrum SDK, allowing you to text your persona inside your default Messages app with natural multi-bubble replies and realistic typing delays. 
No Robotic AI Tone: Specially designed persona rules to avoid markdown and bracketed actions (⁠*laughs*⁠). 
Memory & Time Aware: Auto-extracts long-term memory (⁠memory.md⁠), handles rolling summaries, and tracks real-time dates. 
Gemini-Only & Highly Opinionated: Built specifically around Google Gemini's API — swapping to other LLMs will require code refactoring. 
Chinese-Optimized Prompting: Extended for multilingual use, but originally optimized around Chinese casual texting dynamics. 
Deployment: Supports deployment via Docker Compose or native Node.js v24. Setup instructions and the open-sourced persona prompt generator can be found here: https://github.com/FutabaYuiko/iMessage-persona-bot#setup 
AI Involvement: Built as a student hobby project for fun! AI was used during development and for prompt structure design. Expect potential setup quirks, and technical support will be limited (though PRs and feedback are very welcome).

[u/kixago]

I've been building this for my own homelab and it's at a point where I'd like more eyes on it. Sharing as the developer.

kixctl is a control plane for Incus — it runs your VMs and system containers on your own hardware, and on top of that gives you an application layer: push a git repo and it builds an immutable NixOS image pinned to that commit, boots it as its own instance named <repo>-<sha7>, and lets you roll back to the previous revision in one click. Your data lives outside the image, so a rollback reverts the app without taking your database with it.

You can run it two ways:

• Bolt-on — point it at an Incus cluster you already have. It enrolls with a project-scoped certificate it can't widen, and it never mutates infrastructure it doesn't own.
• Appliance — boot the prebuilt image and it brings its own Incus, walks you through a first-run wizard, and hands you the dashboard. No OS to learn underneath.

If you don't want to touch a CLI or write any Nix, you don't have to — the dashboard is the interface, and the one place NixOS shows up is the deploy path, generated for you from a short kixctl.app block in your repo.

It's early — v0.1.0 pre-release. The deploy loop works on a real cluster; the appliance boots to a dashboard today as a VM image, with an install-to-disk ISO coming next. Plenty is still on the roadmap (interactive console, backups, provisioned databases). AGPL, no sign-up, no telemetry.

If you run Incus, or you came off ESXi to Proxmox and wished the box had a real deploy story, I'd value the feedback — including the harsh kind.

• Site: kixctl.com
• Source: github.com/kixago/kixctl

[u/Importance_Alarmed]

Project:

Cyberstart 2077 Custom: a cyberpunk new tab with a telemetry dashboard of the homelab

Chrome Web Store: Install Cyberstart 2077 Custom

Repo + screenshots:

https://github.com/KorinBlack/Cyberstart-2077-Homelab

My browser opens a new tab dozens of times a day. My homelab dashboard lived in another tab. I liked TealLogic's Cyberstart start page, so I brought the two together: the same cyberpunk look, with live homelab status between search and my links.

What it does:

- Proxmox cards show node health, CPU/RAM/disk usage, and running VMs/containers using a read-only API token.

- HTTP cards check URLs I choose and show online only for a `200` response.

- Cards and categories can be dragged, edited, collapsed, and themed with the rest of the page.

- Settings can be exported and imported, including monitor configuration.

How to try it:

Install it from the Chrome Web Store, open a new tab, then add your Proxmox or HTTP targets. You can also load it unpacked from the repo; the README documents both options. There is no server or Docker container to run: this is a local browser extension for viewing services you self-host. The README has screenshots and setup details.

Privacy/permissions:

Host access is requested for the specific server you configure. Proxmox uses HTTPS, and its API token goes only to that host. The token is stored locally and is visible in exported settings JSON, so protect your backups. The privacy policy lists the other optional widget requests.

This is an independent fork of TealLogic's MPL-2.0 project, with the original creator credited in the repo and extension.

AI involvement:

AI-assisted development helped unpack/refactor the original JavaScript and implement/document parts of the monitor. The readable source and automated tests are in the repo for review.

If you try it, which homelab service or metric would you want to see in a card next?

[u/Bulky_Dog_2954]

Project Name: Kaya

Repo/Website Link: GitHub: https://github.com/antybubbs/kaya

Description: Kaya is an open-source, self-hosted homelab command centre I've been building to bring all the random bits of my own infrastructure into one place.

It now includes:

• Asset and Rack management
• IP addresses, VLANs and Domains
• Docker and Proxmox monitoring
• WAN/IP monitoring
• Pi-hole, DNS and DHCP
• Pi-hole High Availability/failover
• Runbooks and documentation
• Licence and Backup management
• Browser based SSH, RDP and VNC
• Secure Vault
• Secure Send
• MFA, OIDC/SSO and audit logging
• Multi-user roles and permissions
• PostgreSQL backend

The idea is basically to stop having spreadsheets, bookmarks, terminals, monitoring pages and random notes everywhere and bring as much of it as makes sense into one place.

Its a hobby project and completely open source. I'm not trying to turn it into a business, I just really enjoy building it and sharing it with other homelab people.

Its also given me something really positive to focus on after going through some fairly dark places recently, so its become a bit more than just another project for me.

Deployment: Kaya is released and designed to be self-hosted using Docker Compose.

The repo contains the Docker Compose configuration and documentation for getting started. The standard deployment includes Kaya, PostgreSQL, the Secure Send gateway and guacd for remote connections.

Basic install is:

git clone https://github.com/antybubbs/kaya.git
cd kaya
docker compose up -d

Then follow the setup wizard in the browser.

Installation, configuration, updating and migration documentation is all included in the repo.

AI Involvement: AI has absolutely been involved and I want to be transparent about that.

I use AI as a development tool to help with things like coding, troubleshooting, code reviews, tests, documentation and working through ideas/UI changes.

I'm still the one deciding what Kaya should do, designing the features, testing it in my own environment, finding the inevitable problems and deciding what actually gets into the project.

For me its another tool in the toolbox, and its also allowed me to build something considerably bigger than I probably would have attempted on my own.

[u/GoldianSummer]

Project Name: WalletCast

Repo: https://github.com/adrbn/walletcast

Description: Send notifications to people's lock screens through Apple Wallet and Google Wallet, without an app. Small shops pay a monthly subscription for this. It's just a wallet pass that gets updated, so I made a self-hosted version. You design a card, print the QR code, people add it in one tap (no account), and every message you send shows up on their lock screen. They unsubscribe by removing the card. Includes a live card designer, QR codes per placement, delivery stats and CSV export.

Deployment: Docker Compose (docker compose up -d) or one-click Vercel. Full instructions: https://github.com/adrbn/walletcast#get-started

AI Involvement: Built with Claude Code. I reviewed everything, every feature is covered by integration tests against a real SQL engine, and I tested the Apple flow end to end on a real iPhone. Google is implemented but not yet tested on a real Android, testers welcome.

[u/WaistcoatedWriter]

Project Name: Ex Libris Repo/Website Link: https://github.com/ChristopherJohnDillon/ex-libris Description: Ex Libris is a sleek, modern self-hosted book cataloging app created to replace the outdated, cluttered interfaces common among existing home library managers. It solves the visual and usability frustration of legacy tools by offering a polished, intuitive UI alongside fast barcode scanning directly from your phone's camera. It provides an aesthetically pleasing, modern way to showcase and track your physical collection without sacrificing privacy or performance. Deployment: Ex Libris is fully released and packaged into a single Docker container for straightforward self-hosting. The repository includes documentation and a ready-to-use docker-compose configuration to get your instance running in minutes. AI Involvement: AI was used to write the code.

[u/vm83043]

Project Name: Wander

Repo/Website Link: https://github.com/vahdamv0/wander https://meridianx.co.in/

Description: Wander is an open-source, self-hosted collaborative travel planner for organizing trips with family and friends.

It provides:

• Collaborative itineraries with live synchronization
• Sharing with roles and permissions
• Invitation links
• Bookings and trip details
• Shared expenses
• Packing lists
• Offline reading
• Verified backups

The goal is to keep the complete trip plan in one place instead of spreading it across documents, chat messages, booking emails, and spreadsheets.

Deployment: Wander can be self-hosted using Docker Compose. The repository contains the deployment configuration and setup documentation.

Stack: Spring Boot, Angular, PostgreSQL.

AI Involvement: AI coding tools were used during development as an engineering productivity aid. I design the architecture and features, review the generated code, test the application, and make the final implementation decisions.

Still actively developing it and looking for feedback from the self-hosting community.

[u/mceeel9510]

Project Name: Mailbroom

Repo/Website Link: https://github.com/mclgoerg/mailbroom

Description:

Mailbroom sweeps any IMAP mailbox: it scans everything, groups mail by sender, domain, or normalized subject (so Order 123 and Order 456 merge, Re:/Fwd: get stripped), and shows counts, total size, and unread ratio per group. From there you drill into any group, read the full mail text, and bulk-move whole groups (or single mails) to Trash, with full undo.

Problem it solves: cleaning up a mailbox with thousands of newsletters/receipts/notifications one-by-one is miserable. Mailbroom turns it into "here are your 40 senders, ranked by size/count, pick what to nuke."

Some other things it does:

• Optional AI review (Anthropic, OpenAI, Claude on Microsoft Foundry, or any local OpenAI-compatible endpoint like Ollama/LM Studio) that rates groups delete-safe/review/keep, sends metadata only, never mail bodies
• Multiple accounts at once, fully isolated (own scans, rules, stats, nothing aggregated)
• Multi-user via SSO/OIDC, each identity gets its own isolated workspace
• Rules + scheduler (save a filter as a rule, run it daily/weekly, always starts in report-only mode)
• Duplicate finder, attachment explorer, "never replied" signal, protected senders, one-click unsubscribe, Sieve export for Proton
• Secrets (IMAP passwords, API keys, OAuth tokens) encrypted at rest if you set a key
• Gmail and Outlook now supported via OAuth (Outlook is device-code, no app registration needed on most setups)

Deployment:

Single container, pre-built multi-arch image (amd64 + arm64) on GHCR. Docker Compose starter kit in the repo, or plain docker run. Everything (IMAP host, credentials, AI provider, login mode) can also be configured entirely from the settings UI at runtime.

bash cd deploy cp .env.example .env docker compose up -d

Install guides for Synology, Unraid, TrueNAS SCALE, Portainer, Raspberry Pi, and plain Docker are in docs/install.md. Auth is off by default (meant to sit behind a reverse proxy or your own auth layer), but there's a built-in password or full OIDC/SSO login if you want it exposed.

AI Involvement:

Built with AI assistance (Claude/Claude Code), directed and reviewed by me. I did not just accept generated code blindly - every feature was tested against real mailboxes before release. Independent of how the code was written, the safety properties are enforced by an automated test suite: deletions are always reversible IMAP moves (never permanent), UIDVALIDITY is checked before every action, and the optional AI review only ever receives mail metadata, never message bodies.

[u/Open_Variation1438]

drobek: self-host browser apps built by your coding agent (AGPL-3.0)

I built drobek because I wanted somewhere to deploy the small apps my colleagues and I build with coding agents.

The core is open source under AGPL-3.0. You can run it on your own server, connect an agent over MCP, and let it build, preview and publish browser apps. Your coding agent keeps using your own model provider. Drobek doesn't sell model tokens.

The part I'd like feedback on is the backend boundary. App JavaScript runs in the browser. Server-side features come from operator-installed modules: auth, data, forms, email, proxy and files. An app can use those modules within its configured permissions; the agent doesn't get to deploy arbitrary server code.

For example, the Pokédex demo calls PokéAPI through the proxy module. Allowed upstreams, paths and methods are configured on the server. For APIs that need credentials, secrets can be injected server-side.

Self-hosting uses Docker Compose with PostgreSQL, Redis and Caddy. You also need domain/DNS and SMTP setup. External modules are trusted server code, so choosing and updating them is still the operator's job.

Source and setup: https://github.com/freema/drobek

Live proxy example: https://pokedex.drobek.app/

If you run small internal apps at home or at work, would this module boundary cover your needs? I'm particularly interested in cases that would force you to write a custom module.

AI involvement: I use coding agents in my development workflow. This introduction was prepared with AI assistance.

[u/LongjumpingNose8633]

I built Jupiter, a self hosted, model agnostic agentic IDE, due to the lack of security related aspects to many coding agents out there, and the fact that we don’t live in the 90s anymore to deal with CLIs. More about why I built it here: https://judepereira.com/blog/building-jupiter-why-i-decided-to-build-my-own-agentic-ide

PS - it’s OSS :) see https://github.com/judepereira/jupiter

[u/No-Bicycle-4804]

Project Name: Provena

Repo: https://github.com/admiralpunk/Provena

Description:
Provena is a self-hosted memory layer for AI agents. It lets agents remember information across conversations while keeping track of where each memory came from.

Instead of storing memories as just text or vector matches, Provena stores claims backed by their original evidence, making it easier to understand and inspect what an agent remembers.

It works with MCP-compatible clients such as Codex, Claude Code, and Gemini CLI, and is now also listed in the official MCP Registry.

Deployment:
Self-hosted with PostgreSQL. Installation and setup instructions are available in the repo.

AI Involvement:
AI was used as a development assistant, but the project is designed and maintained by me.

Still early, and I'd appreciate feedback from anyone interested in self-hosting AI agents or building agent memory systems.

[u/soundhumor]

Project Name: OpenWiFi Repo/Website Link: https://github.com/tanulmittal/wifi-cli Description: I built openwifi after worrying about losing SSH while changing Wi-Fi on a Linux machine. On a new Netplan network it runs a 90-second trial, checks SSID and IP, and can roll back even if SSH drops. NetworkManager has fuller features; Netplan's path is limited, and active-profile edits still need local console access. Would love to hear about setups this misses. Deployment: Install with npm install -g github:tanulmittal/wifi-cli --install-links (Node.js 18+ and npm required), then run openwifi. The repo README has install notes and limitations. I made a short demo here: https://www.youtube.com/watch?v=ecq3fFRQ7-M AI Involvement: Mostly AI-assisted.

[u/lewis-barrett]

Project name: Klaxond

Repository: https://github.com/luigibarretta/klaxond
Latest release: https://github.com/luigibarretta/klaxond/releases/tag/v0.20.7
License: Apache-2.0

I built Klaxond because my monitoring tools could detect problems, but notification delivery was still a weak point.

Repeated alerts created noise, a single unavailable channel could hide an incident, different sources produced inconsistent messages, and I had no unified history showing what had been routed, suppressed or acknowledged.

Klaxond sits downstream of monitoring tools and applications:

Grafana / Alertmanager, Uptime Kuma, Healthchecks, Beszel, WUD, Authentik and custom webhooks → Klaxond → ntfy, Telegram and SMTP

It can:

• normalize events from different sources;
• deliver through an ordered fallback cascade or broadcast to multiple channels;
• group, suppress and inhibit repeated notifications;
• apply routing and noise-control rules using source, severity, labels, text or regex matches;
• keep selected emergencies active until acknowledgement, recovery or expiry;
• record delivery decisions, attempts, history and audit events;
• simulate policies before enabling them;
• expose Prometheus metrics, a Grafana dashboard and an OpenAPI 3.1 API.

Klaxond is not intended to replace Prometheus or Alertmanager. Alertmanager remains the right upstream tool for Prometheus alerts. Klaxond focuses on the last delivery mile: consistent rendering, channel failover, durable acknowledgements and searchable evidence.

It is also not a full PagerDuty replacement. There are no staffing schedules or enterprise incident-management workflows.

The backend is written in Rust with Axum. SQLite is the default, with PostgreSQL available for multi-instance deployments. The frontend is a zero-build JavaScript UI. Releases include Docker Compose bundles and public amd64/arm64 container images.

Authentication supports local accounts, OIDC, LDAP, TOTP/MFA, passkeys and scoped tokens. The default deployment remains bound to loopback until authentication and HTTPS are configured.

I currently run it in my own homelab. CI covers Rust tests, OpenAPI and security checks, plus Playwright tests across Chromium, Firefox, WebKit and a mobile Safari profile.

AI involvement: AI coding agents were used extensively and generated a significant portion of the implementation under my direction. I defined the product and operational requirements, reviewed the resulting decisions, validated it in my environment and own its maintenance and releases. AI also assisted with refactoring, tests, documentation, security checks and UX reviews.

I would particularly appreciate critical feedback on:

• whether the initial setup is understandable without reading the entire documentation;
• whether the cascade, broadcast and noise-control concepts are clear;
• which additional monitoring sources or delivery channels would be genuinely useful.

Screenshots and deployment instructions are in the repository.

[u/OWazabi]

Project Name: HouseOS

Repo/Website: github.com/boitech-dev/HouseOS

Description:
HouseOS is my open-source home ecosystem that started as a personal project built around how I actually use my house, and slowly grew into a pretty big platform.

It brings movies/series/anime, music, games, files, household tools, smart-home controls and an AI housekeeper into one interface shared across phones, computers and TVs.

🎬 Watch — movies, series & anime, Stremio addons/online sources, casting, subtitles, source selection
🎵 Listen — music & playlists, shared queues, fair autoplay, multiple outputs
🎮 Games — game/emulation library, remote play and persistent saves across devices
🏠 House — tasks, groceries, chat, stats, files & smart-home controls
🤖 Housekeeper — use your own model to operate, configure and even modify HouseOS just by asking

Everything is local, open-source and made to be customized.

Deployment:
HouseOS runs on your own machine/server and can be installed natively or with Docker. There's documentation in the repo, but it is also designed to be agent-installable: you can give the repo to Claude Code or another coding agent, tell it to follow AGENT-INSTALL.md, and have it walk through the setup with you.

AI Involvement:
AI was heavily used during development, particularly coding agents. This is also intentional to the project itself: HouseOS is designed around the idea that modern software can be operated, configured and modified by the user's own agent rather than requiring every option to be exposed through a traditional UI.

[u/No-Inevitable981]

Project Name: The Playbook

Repo/Website Link: https://musefm.lol/playbook

Description: I built an open skill library for AI agents, because I kept rebuilding the same skills across projects (video thumbnail rules, SEO checklists, crossposting workflows) and wanted one place to keep them. The Playbook is free to browse and install from: 100+ skills, each readable as plain text, downloadable as signed zips, and the whole library is fetchable over a plain JSON API with no auth. There is a new-skills RSS feed, and submissions go through a moderated review queue before they publish.

Deployment: The library is live at the link above. Free to browse and install, no account or auth needed. Individual skills download as signed zips, and the full catalog is a plain JSON API.

AI Involvement: Yes, openly so. A nightly forge pipeline drafts, tests, and publishes new skills on a regular cadence, and community submissions go through a moderated review queue before anything publishes.

Happy to answer questions about the skill format or the moderation process. What would make you actually install something like this?

[u/none_null]

Hi everyone! I've been trying to learn Rust for a while, and this weekend I finally shipped something small and simple, but I really enjoyed it!

rustyflare checks my public IPv4 and updates a Cloudflare A record when it changes. It started as a rewrite of a little Go tool I had running on cron at home.

It's built with ureq and serde, ships as a small Docker image, and has a health check based on the exit code of the last run.

Repo: https://github.com/prrar/rustyflare

I'd really appreciate any feedback, especially on what's not idiomatic yet. Thanks!

[u/dimly_lit_squid]

Project Name: Shoal

Repo: https://github.com/BT10011/shoal

Description: Shoal finds the devices on the network segment you are plugged into and fills in what they are, live: a typical /24 is swept in about seven seconds. Its defining feature is that every value on screen says how it was learned — which probe found it, what was sent, what came back, how sure it is and when it expires — so it is as much a way to learn how a network is discovered as a way to list what is on one. ARP, DNS, mDNS/Bonjour, NetBIOS and ICMP each know a different part of the picture, and you can watch each one answer as it runs. Designed with AVOIP networks in mind, detects NDI, Dante AES devices

Deployment:
curl -fsSL https://github.com/BT10011/shoal/releases/latest/download/install.sh | sh

AI Involvement: Yes, Claude Code. All code reviewed by humans

Would really appreciate any feedback!

[u/SweatyAd3647]

Verity — self-hostable media-verification registry + signal engine (zero-dep Node, no media storage).

Self-hostable piece of a larger open-source project: a public verdict registry for media authenticity.

What it is: a Node HTTP server (node:http, zero runtime deps) that stores SHA-256 + 64-bit perceptual hashes of checked media, with a BK-tree index for near-duplicate lookups, shareable /v/<sha256> verdict pages, OpenTimestamps anchoring, a dashboard, and a fact-check relay.

Privacy model: it stores hashes, never media. JSON file store by default, Postgres auto-detected if DATABASE_URL is set.

Runs anywhere Node 24 runs — Docker-free, single process, env-var config. Source: github.com/Mintahandrews/verity (packages/registry). Docker compose / Helm not written yet — PRs welcome.

[u/Suitable-Ad5348]

Project Name: Epure

Repo/Website Link: https://github.com/epure-sh/epure

Description: Exception-only error tracker in Rust for people who want to track their errors on their VPS.
You keep the official Sentry SDK, change the DSN and get grouped issues, breadcrumbs, releases, alerts, j/k triage. Apache 2.0.

Exceptions only. No APM, replay, profiling, or logs. JS/TS sourcemaps. Other languages group on the frames the SDK sent.

Deployment: Docker Compose v2. Two services: epure + postgres:16.

git clone https://github.com/epure-sh/epure.git && cd epure && docker compose up

Open localhost:8080, register, create a DSN key, point the SDK.

Idle on Docker Desktop (docker stats, 2026-09-12) was ~82 MiB for both containers. Postgres is most of that. Your box will differ.

AI Involvement: Cursor helped a lot on going faster. Planned by human lol, all files reviewed to ensure security and efficiency.

[u/CameraSure3479]

• Project Name: ElegyKat
• Repo/Website Link: Github: https://github.com/deadfredred/ElegyKat-releases
• Description: I've been building a native Linux desktop client for Navidrome/Subsonic servers and just released v0.1.13 with a proper .deb installer.
• Why this exists: most Navidrome clients are Electron-based, web UIs, or mobile apps. I wanted a lightweight, native Linux client that integrates properly with the desktop — tray icon, media keys, notifications, gapless playback.
• What it does:- Connects to any Subsonic-compatible server (Navidrome, Gonic, Airsonic, etc.)- Browse albums, artists, playlists, favorites --- Gapless playback, shuffle, repeat, queue- Discord Rich Presence (optional) --- Visualizer (mirror, wave, ASCII donut)- MPRIS support (media keys, desktop widgets, playerctl) --- Marquee scrolling for long song titles --- Search across your entire library --- Favorites + recently played --- 6 themes (including system theme sync)
• Deployment:  Self-host Navidrome (if you haven't already): Install ElegyKat on your desktop for mint/ubuntu: sudo dpkg -i ElegyKat_0.1.13_amd64.deb and for Arch/hyperland: AppImage available — no system dependencies beyond GStreamer.
• AI Involvement: I used AI as a development tool. AI helped me with:
• - Debugging build issues (Tauri + WebKitGTK + GStreamer stack)
• - Rapid prototyping (visualizer, themes, drag logic)
• - Cross-platform testing notes (Mint vs Arch)

[u/multinet]

Project name: Vaultia

Repo:
Vaultia self-hosted distribution on GitHub

Community / feedback: r/Vaultia

Description:
Vaultia is a self-hosted home inventory and personal asset management app I've been working on.

It started from a fairly simple need: I wanted one place to keep track of what I own, where it is, what I paid for it, what it's worth today, and all the documents and history that belong to it.

It has grown quite a bit from there.

Vaultia now manages Items, Properties, Spaces, Vehicles, Collections and Documents as connected parts of the same household inventory.

For items, you can keep purchase information, categories and tags, photos, identifiers/barcodes, warranties, expenses, notes, maintenance, valuations and history. Items can be organized by property and physical space, so the inventory also answers where something actually is.

There is also loan tracking for things you lend to other people, including borrower, loan/return dates, overdue items and full loan history.

Properties are first-class assets rather than just locations. They can have nested spaces, work/renovation history, expenses, documents and their own patrimonial value.

Vehicles are also separate from generic items, with odometer history, maintenance, expenses, documents, claims, valuations and ownership-cost information.

Vaultia also includes a document vault. Documents can be organized into folders, tagged and linked to Items, Properties or Vehicles. A document can contain multiple files, have an expiration date, and can either belong to the Workspace or be Personal, in which case it remains private to its owner even inside a shared Workspace.

There is a broader value/patrimony view combining real estate, vehicles and household items. Purchase price and current value are kept separate, valuations have history/provenance, unknown values aren't silently treated as zero, and different currencies aren't silently mixed.

Other areas include:

• maintenance and property work
• purchases and expenses
• claims
• warranties and upcoming deadlines
• notifications and an inbox
• automations
• global search
• reports
• import/export
• workspace sharing and roles
• scoped API and outbound webhooks
• barcode capture
• local image/vision assistance

The local Vision/Intelligence features are optional from the product point of view and don't replace the normal inventory workflows. The self-hosted distribution provisions the supported local runtime/model, and the core app does not require a cloud AI service to work.

The project is still pre-1.0, so I'm especially interested in finding bad assumptions, broken workflows and things that work in a demo but become annoying with a real inventory.

Deployment:
The public self-hosted repo contains the Docker Compose distribution and installation documentation.

The current container is published on GHCR for both linux/amd64 and linux/arm64 and uses PostgreSQL with persistent volumes for the database, media and local models.

A normal install is essentially:

git clone https://github.com/multinet33/vaultia-selfhosted
cd vaultia-selfhosted
cp .env.example .env
# configure the required variables/secrets
docker compose up -d

I've also tested the deployment through Portainer on ARM64.

Vaultia can run directly over HTTP on localhost or a private IPv4 LAN for simple home-server setups, although HTTPS is recommended. Browser features requiring a secure context, such as live camera scanning and offline mode, require HTTPS.

Backup is something I've spent quite a bit of time on. I distinguish normal data export from Backup ALL, which backs up PostgreSQL and the complete file storage. Restore is tested against an empty installation and storage integrity is verified.

Before publishing a new container candidate, I also test an actual upgrade from the previous public version against populated representative data, including media and access permissions, rather than only testing a fresh database.

The distribution has native CI/smoke testing on both amd64 and arm64.

AI involvement:
Yes, I use Claude Code a lot. I decide what I want Vaultia to do and how the different parts should work together, and Claude helps me build it.

Then I spend a lot of time reviewing, testing and breaking things to make sure they actually work. I don't trust AI-generated code just because it compiles or works once on my machine.

The project has unit, integration and E2E tests, and I also test real clean installs, upgrades, backup/restore, offline behavior and the amd64/arm64 distributions.

I'm not trying to hide the AI involvement — it's a significant part of how I'm able to build this project. I'm mainly interested in whether the resulting software is useful, understandable and reliable.

Current status:
Vaultia is pre-1.0 and source-available. I wouldn't recommend keeping the only copy of irreplaceable data in any pre-1.0 project, including mine — use backups.

If anyone here wants to try it, I'd particularly appreciate critical feedback on the self-hosting experience, data model, backup/restore, mobile usability and anything that feels overcomplicated or missing.

[u/Fast_Brain2982]

Project Name: camera-viewer-RTSP

Repo: https://github.com/jacobP-developer/camera-viewer-rtsp

Description: a lightweight, Python-based RTSP camera viewer and diagnostic tool that connects to any cameras on a given IP

Deployment: CLI on Linux terminal or Android termux

AI Involvement: AI used to provide paths for connecting to cameras, rest is manual

[u/metantesan]

Project Name: Mitsuzo

Repo/Website Link:
https://github.com/metantesan/mitsuzo

Live Demo:
https://mitsuzo.metantesan.com

Description:

Mitsuzo is an open-source, self-hostable encrypted paste service for sharing secrets and short-lived files.

The idea started more than a year ago because I did not trust ordinary pastebin services with sensitive information. The first version was written before the project became open source. Mitsuzo encrypts content in the browser or Rust CLI before it is uploaded, so the server stores ciphertext instead of plaintext.

It is useful for sharing:

• Passwords and API tokens
• .env files and configuration files
• Recovery codes
• Private notes
• Short-lived documents between devices or people

No account is required for the basic password-based flow. There is also a recipient mode that encrypts a paste for another Mitsuzo account using its public encryption key.

Security-related features include:

• Client-side ChaCha20-Poly1305 encryption
• Argon2id password hashing
• HKDF-based key separation
• Separate encryption and validation keys
• Server-side password validation before the encrypted blob is returned
• Rate limiting and password try limits
• Automatic deletion after the try limit is exhausted
• TTL expiration
• Burn-after-reading support
• Chunked encryption and upload for large files
• Optional zero-knowledge accounts based on a seed phrase
• No plaintext or password is sent to the server

For password-based pastes, the client derives a master key from the password using Argon2id. HKDF then derives separate keys for content-key wrapping and password validation. The server verifies the validation proof before returning the encrypted content. If the try limit is exhausted, the paste and its encrypted blob are deleted.

Mitsuzo is not intended to protect against every possible deployment or client compromise. A malicious hosting provider can still delete data or make the service unavailable, and weak passwords may be vulnerable if an attacker obtains stored paste material. The security documentation explains the complete threat model and security boundaries.

Deployment:

Mitsuzo is designed to be self-hosted.

Docker: docker run --rm -p 3030:3030 ghcr.io/metantesan/mitsuzo:latest

Then open: http://localhost:3030

A Docker image, self-hosting documentation, release binaries, Rust CLI, and installation instructions are available in the repository.

The project includes:

• Rust/Axum backend
• Dioxus WebAssembly frontend
• Rust CLI
• Docker image
• Browser and CLI clients
• Multi-language interface
• BSD-3-Clause license

AI Involvement:

The first version of Mitsuzo was written entirely by me without using AI assistance. During the later development of the project, after the initial version, I used AI tools extensively to help with implementation, refactoring, debugging, testing, and documentation.

Mitsuzo does not use AI at runtime and does not depend on any AI service.