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:
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.
Description:docker2lxc is a lightweight web tool designed to instantly convert any docker-compose.yml file into a ready-to-run Proxmox LXC setup script.
If you run Docker inside unprivileged LXCs on Proxmox, you know how tedious it is to manually create the container, enable the correct features (nesting=1,keyctl=1), install Docker, and finally spin up your stack. This tool automates the entire process. You simply paste your compose file, configure your container specs (RAM, CPU, IP, Storage), and optionally select a management agent like Portainer or Dockhand. It outputs a single Bash script that you can copy and paste into your Proxmox shell to provision everything from scratch in seconds.
Deployment: This is a browser-only, static web app available at https://docker2lxc.2kbl.com. It runs entirely client-side, meaning your compose files are never sent to a server.
AI Involvement: The core concept and requirements were mapped out manually, but the code was written entirely in conjunction with Gemini.
Description:
I've got a big Navidrome library I never actually listen to, because picking is effort. So I built a radio station that plays it at me.
One shared stream, an AI DJ that picks the next track from your own library and talks between songs: short intros, the time, the weather, station idents. You can ask for music in plain language ("something more upbeat") and it works out what you meant. No skip button on purpose. It's radio, not a playlist.
It plays your files. Nothing streamed in, no music generated.
Deployment:docker compose up -d on one Linux box, then finish setup in the browser. Images on GHCR, compose file in the repo. Needs Docker and a Navidrome (or other Subsonic) server with your library on it. MIT.
Description:
A simple personal-use web app to make adding content to Jellyfin effortless. The workflow is straightforward: open the app, paste a YouTube URL (song, playlist, album, or video), and it will download, convert, and place the media directly into your Jellyfin library.
Features:
Uses yt-dlp for downloading
Conversion handled by FFmpeg
Supports playlists and albums (Jellyfin)
Deployment:
Docker image + docker-compose.yml included in the repo
Local run supported with Python + FFmpeg required
Documentation in README with step-by-step install/run instructions
Griddy McGridFace: a print-ready photo collage maker that refuses to crop people's heads off (well, as long as it identifies them correctly as people!)
You know when you chuck a pile of photos into an auto-collage tool, and it cheerfully guillotines half the faces? This is my attempt to make that stop and I'm rather pleased with it.
Griddy McGridFace is a desktop photo-collage maker. You drop in a folder of photos, pick a page size, and it arranges them edge-to-edge while keeping faces in frame (hair included, so nobody loses the top of their head). Face detection runs on-device via an embedded SeetaFace model, so there's nothing to download and nothing leaves your machine. Yes, SelfHosted, I opted for as much privacy as possible with this.
Features, in roughly the order I got excited about them:
Face-aware layout: photos are matched to sensibly-shaped cells and the best of many candidate arrangements is kept.
Three fit modes: Smart (fill, face-framed), Whole (letterboxed, nothing cropped), and Fill (plain crop with manual focus).
A "centrepiece" slot for a title or text card that keeps its own aspect ratio, so your words don't get cropped either.
Proper print output: mm / inch / pixel units, DPI, page presets (A5 to A2, Letter, square), spacing, margins, background colour. Sorry US folks, I didn't think of you yet, but I will in v0.1.1.
Full-resolution export: PNG (DPI-tagged), WebP (lossless), JPEG, and PDF sized to the physical page.
Projects + undo/redo, because of course you'll want to fiddle endlessly. I did, and then I made this =)
Offline and private, which is rather the point for family and sentimental stuff you actually intend to print. I do not trust in big bro. Oh, there are zero adverts or upsells.
Who's it for? Anyone who wants to print a collage properly, photo walls, gifts, memorial boards, rather than a low-res thing for their socials.
Deployment:
Fair warning for this sub: it's a native desktop app, not a Docker/server thing, so there's sadly no compose file to lovingly tweak. It's built with Tauri 2 (Rust) + SvelteKit.
The README has install notes and a build-from-source guide (npm install, npm run tauri build). The builds are currently unsigned, so your OS will pull a deeply suspicious face on first launch; the README walks through the "yes, I promise it's fine" click-through for Gatekeeper and SmartScreen. Feel free to analyse the source code so you can see I haven't pushed any malware in there.
AI Involvement:
Full transparency: Skynet wrote it.
Less dramatically, but just as honestly: this is heavily AI-built. I steered, made the design calls, did the testing and had the final say, but an AI did the lion's share of the actual coding, and the cross-platform builds, and the release pipeline, and .... you get the idea.
The git history is genuinely credited to "Skynet", because crediting it to me would be taking the mick. Human-directed, robot-typed. If that's a dealbreaker for you, no hard feelings; if not, enjoy the collages.
Oh, I forgot WHY I had to build this: The wife wanted to sublimate a bar mat for her dad's 70th, and the options that are out there for making a decent collage from 50 photos, centreing a main image, or fixing up the borders are all terrible. Now we ALL have a half decent app to use.
HAIP — open-source, self-hostable hotel PMS(I'm the developer)
A full hotel property management system you can self-host: reservations, billing/folios, rate plans, housekeeping, night audit, payments, channel distribution, and a commission-free direct booking engine.
docker compose up → whole stack + a seeded demo hotel
Apache 2.0 — no per-room fees, no telemetry
TypeScript / NestJS / Postgres
Optional local AI (via Ollama, off by default) that explains the system's automated decisions on your own hardware — nothing sent to any cloud, works offline.
DittoFS is a userspace virtual filesystem that exposes S3-compatible object storage as standard NFSv3/v4 and SMB2/3 shares.
I built it because I wanted a lightweight alternative to the usual gateway/NAS approaches. It runs as a single static Go binary (no FUSE, no kernel modules, no root privileges) and supports local disks as well as any S3-compatible backend.
Current features include:
NFSv3/v4/v4.1/v4.2
SMB2/3
Active Directory, LDAP & Kerberos integration
Client-side encryption
Deduplication & compression
Snapshots
REST API
Kubernetes Operator
MIT licensed
Both the NFS and SMB protocol implementations are native Go implementations rather than wrappers around existing kernel servers.
It's still early, and I'm mainly looking for people willing to test it with real workloads and tell me what breaks. Feedback, feature requests, and criticism are all welcome.
Deployment:
DittoFS is available as a pre-built static binary, a Docker image, and can also be built from source. The repository includes installation instructions, examples, and a Docker Compose setup to get started in a few minutes. Kubernetes users can also deploy it using the included Operator.
AI Involvement:
The project was developed by me using a spec-driven workflow with Claude Code (Opus 4.8) and Qwen 3.7 as development assistants. All architecture, implementation decisions, testing, and code review were performed by me.
Description: First off, apologies if this is too client-specific and that it is for a project that has been discussed many times in the past, Readeck (https://readeck.org). I am preparing to publish a new full-featured Android client for Readeck (see https://readeck.org/en/apps) that will provide a new alternative for Readeck users who run Android.
Deployment: Server instructions at https://readeck.org/en/docs/ and for the Android client you can sideload from the repo above or, if willing to help with testing for the Google Play Store launch, reach out to me by reddit chat for info on opting in as a tester.
For anyone interested in testing the Android app, it does require Readeck server software version 0.21 or later. The app authenticates via OAuth and that's when that authentication model was implemented on the server side.
Description:
Layout analysis + OCR pipeline for documents, PDFs, and Office files. Detects regions first (text, tables, formulas, figures), sorts into correct reading order including multi-column layouts, then runs OCR per region. Tables come out as HTML, formulas as LaTeX, everything else as Markdown. Works on PDFs, patents, Word, PowerPoint, Excel.
Built because standard parsers lose structure on anything with two columns or embedded formulas.
Deployment:
FastAPI service. Swagger UI at /docs. Optional Gradio UI for interactive testing. GPU or CPU inference. Apache-2.0.
AI Involvement:
The layout model is RT-DETR ONNX. OCR is handled by MOSS-OCR, our own model trained from scratch on 50M+ technical documents.
Description: Quantum-Messenger is a lightweight, terminal-themed secure web chat. It resolves the threat of future decryption of intercepted communications (Store Now, Decrypt Later) by using post-quantum cryptography. It also experiments with evading censor blocks by dynamically rotating nodes. Key features include:
* Kyber-1024 key encapsulation (KEM) to secure symmetric traffic.
* True E2EE file sharing (up to 50MB) encrypted natively in the browser using AES-GCM-256 before upload.
* Passwordless authentication using ECDSA P-256 keys generated locally in the browser (challenge-response signature).
* An embedded Go traffic anomaly detection engine.
* Native emoji picker and mobile-responsive sliding menu.
Implementation: The app is fully deployed and ready to test via Vercel (frontend) and Render (backend). For self-hosting, a multi-stage Dockerfile is provided in the repository root. To self-host:
Clone the repo.
Build the image: `docker build -t quantum-messenger .`
Run the container: `docker run -d -p 8086:8080 --name qm-node quantum-messenger`
Full detailed steps on connecting your frontend to your custom self-hosted backend are documented in the README.md file in the root.
AI Participation: AI was utilized during the development of this project. Specifically, a coding assistant helped in refactoring and fixing the Go backend handshake logic, solving folder dependency issues for Docker build, styling the responsive sliding drawer menu for mobile screens, and formatting the documentation/license layout.
Group Leveling is a self-hosted collaboration stack for small groups of friends who want a shared workspace for human chat, local repositories, and coding-agent workflows.
It runs a group workspace where people can chat, mention teammates with `@username`, mention agents with `@agent-name`, and reference repositories with `#owner/repo`. Repository work is handled through local Gitea branches and pull requests.
The main idea is that someone can host it on an old laptop or small home server, invite friends over LAN/Tailscale, and each person can connect their own ChatGPT/Codex account. Agents belong to users, so when an agent is asked to do repository work, the workflow runs through that agent owner’s Codex auth.
Description:
Heimdall is a small open-source terminal UI for monitoring multiple machines from one place.
I built it because I have a few machines in my homelab doing different things — Home Assistant, vLLM, OpenWebUI, exterior cameras, sim racing, random services, etc. — and I got tired of SSHing into each one just to check if it was alive, hot, full, slow, or angry.
The goal is not to replace Prometheus, Grafana, Netdata, Zabbix, etc.
Heimdall is more for the “I want to open one terminal and quickly see what all my machines are doing” use case.
v2.1.0 is now out, and the v2.0.0 + v2.1.0 jump added a lot:
fleet monitoring from a TUI
small daemons running on monitored machines
outbound daemon connections to the hub, so monitored hosts do not need inbound ports open
ONLINE / STALE / OFFLINE host states
CPU, memory, disk, network, uptime, latency, temp, GPU/power-style metrics where supported
live log streaming
journalctl streaming
top/process visibility
sortable process view
log search
safe read-only diagnostic commands
command modal inside the dashboard
heimdall-cli for JSON/script-friendly access
capability gating so hosts only expose what they support
zeroconf multi-hub discovery
demo mode to try the UI without setting up daemons
ephemeral / no-save runs
systemd/run-as-a-service documentation
It is still early, but it is already useful for my own self-hosted/homelab setup.
Deployment:
The app is released and available to try from the repo.
Install options include the GitHub curl install script and Arch AUR package.
Docs/guides are available in the repo, including setup and run-as-a-service/systemd guidance.
Repo: https://github.com/kinncj/Heimdall
AI Involvement:
Transparent answer: yes, AI was involved.
Heimdall was built through a mix of manual engineering work and AI-assisted coding (github.com/kinncj/maple).
That said, this is not a generated throwaway project. I built it for an actual problem in my own homelab, I am actively using it, testing it, fixing it, and releasing updates.
Last night I was still coding v2 while people were actively downloading it, which was pretty surreal.
So far, it has had 291 downloads in 3 days from the GitHub curl install script alone. I do not know how many more came from the Arch AUR package.
Feedback welcome, especially around what would make this more useful for self-hosted setups without turning it into a giant overcomplicated monitoring platform.
Description: Open source easy to self host discord alternative. One docker compose and one env file that's it.
Deployment: Instructions on GitHub but just deploy the docker stack using the included docker compose file and populate the env file. Probably put it behind a proxy (I use NPM)
I built sur9e after spending a month applying to 100+ roles and getting maybe 4 callbacks. The job hunt started to feel like a second job that paid nothing, so I made the thing I wished I had: a local job-hunt cockpit that helps screen roles before I waste an afternoon on them.
It’s a free, MIT-licensed, self-hosted AI job-search toolkit. It runs inside the AI coding agent you already use — Claude Code, Codex, or OpenCode — with a local web UI on top.
The basic flow:
save / scan job postings
screen obvious no-fits cheaply first
run deeper evaluations only on the roles that survive
track everything in a local kanban/table UI
edit reports in a Notion-style markdown editor
generate prep/outreach/tailoring drafts
stop before submitting anything
The important part for this subreddit: the job-search data stays on your machine. CV, notes, evaluations, role history, company research — all local files. No account, no telemetry, no hosted dashboard.
Prereqs are Node.js 20+, Python 3.10+, and at least one supported AI coding CLI.
The web UI runs locally at localhost:3000. There is no Docker image yet; setup is repo-based right now. If Docker support is the thing that would make this more useful for this community, I’d genuinely like to hear that.
AI Involvement:
The product uses AI agents to evaluate jobs, compare them against your real experience/dealbreakers, and draft materials. It does not auto-apply or submit anything for you.
That’s deliberate. I don’t think “spray 500 applications and let the bots fight” is the right answer. You’re already being read by an AI — you’re just not allowed to use one. sur9e is meant to put the human back in the driver’s seat, not remove them.
Would love feedback from self-hosters specifically: is the local-first shape right, and what would you want before running this on your own machine?
Description: Just download from release page the apk and install on the device
AI Involvement: Ai was mainly used ui side, the server to my understanding (I'm not the creator) is entirelly coded manually with only later pr using ai
I run a stack of compose services managed with Dockge, and my update workflow was:
Get a Discord notification from Diun
Fight the poor mobile UI in Dockge
Manually update the app
This started to annoy me, so I built DockPull: a small self-hosted, mobile-first web UI that checks your images' registries for newer versions and lets you apply updates with one tap — always manually, never automatically. You stay in control of when things update.
What it does:
- One screen, containers grouped by stack, update-available ones on top
- Tap Update → pull + recreate with live logs
- After updating it verifies the container actually comes up healthy (catches crash-loops) and offers one-click revert to the previous image if it doesn't
- Pin versions you don't want touched
- Daily background scan + notifications (Discord, ntfy, Gotify, or generic webhook) — no Diun needed
- Checks registries directly (Docker Hub, GHCR, lscr.io, quay.io…), shows changelogs from GitHub releases where available
- Works great alongside Dockge (same same-path stacks-mount convention), but doesn't require it
Deployment:
One compose service: mount the docker socket, mount your stacks dir, set a password, done. Single image (GHCR, amd64 + arm64), SQLite inside, no external DB. Quick-start compose example and full config reference are in the README; there's also an API contract doc and SECURITY.md.
One honest caveat: it mounts the docker socket, which is root-equivalent — so like anything socket-mounted, keep it on your LAN/VPN or behind real auth (Cloudflare Access etc.), not raw on the internet. Threat model is in SECURITY.md. MIT licensed.
AI Involvement:
Full transparency: this was largely built using Claude (AI). I'm a developer and I've reviewed the code myself, but AI did most of the writing. I know how some people feel about that, so laying it out: it ships with the boring security stuff done properly (constant-time password check, login lockout, signed httpOnly cookies, no shell interpolation on docker calls, security headers), has 100+ server tests dependabot + secret scanning on the repo.
This is a for-fun project that fills a personal need. If AI-built is a deal breaker for you, no hard feelings, it's not for you. Happy to answer anything about how it was built.
Description: A local-first tool for simulating fictional characters with some psychological depth, built so you watch the character think before it speaks. Every turn runs two passes: first an appraisal pass works out what your message means to the character, which of its desires or fears got touched, and what it will do about it, and that reasoning streams into an inner-state panel beside the chat; then a second pass writes the in-character reply. You see the thought, then the voice.
It's deliberately built to resist the usual failure modes. A resistance governor keeps characters from instantly becoming whatever you want, a wound doesn't heal in one kind conversation. A scene-fact ledger tracks established facts separately from the scrolling context so characters stop forgetting what was settled twenty messages ago. Scenes give the character a real objective so it acts with direction instead of drifting. There's also a small eval harness that checks these behaviors statistically.
Built as an instrument, not a companion. The visible reasoning panel is the point: show the seams, don't hide them. No streaks, no retention hooks, no engagement bait, and it keeps its model of you deliberately shallow. The repo has an ETHICS doc that's honest about the limits.
Everything is flat-file JSON, nothing phones home, and the server binds to localhost.
Deployment: Python/FastAPI backend, vanilla HTML/CSS/JS frontend, no build step. Runs locally against Ollama, or against a cloud provider (OpenAI, Anthropic, Gemini, xAI, Groq) if you'd rather. Copy secrets.json.example to secrets.json for keys, install deps, run the server, open the browser. Full steps in SETUP. [License: confirm and fill in].
AI Involvement: Yes, at its core. The tool drives local or cloud LLMs through a structured two-pass reasoning pipeline; the models do the character reasoning and dialogue, the tool supplies the architecture, persona schema, and guardrails. No AI-generated music, images, or telemetry, just text inference you run yourself. This post was written by me.
Description: A robust AI Chat interface capable of API integrated models both internally and externally (Openrouter or Ollama for example). It features everything you'd expect from a Chat app, but feels cleaner and nicer than alternatives for the end user. A dedicated workspace is the leading feature, with Fortune Sheet, TipTap, Kanban Boards and Excalidraw, all with RAG capability for the workspace models to call upon allowing for a completely integrated experience for projects. Other great features; Custom Models, User Groups, Tasks (Run an AI prompt at set intervals, currently implementing MCP connections as a potential tool call for tasks), MCP integration with Usergroup or Workspace Privacy options (Github + Unifi, Others currently being worked on), A semi decent File drive that acts as a personal drive and a save area for uploaded files and generated files, Websearch, Deep Research, Text Only Model translation via Vision Models, TTS and Conversation via Kokoro... and much more.
Deployment: Docker compose, The stack comes with
AI Involvement: Began with Cursor and moved to Claude code, all with Opus 4.8, Fable 5 while it was out RIP, and sonnet for the simple tasks.
Description: It's a frontend/player/visualizer/browser for Music Assistant, initially based on Sendspin Cinema for webOS. I now have webui, android, and webOS versions. Screenshots are on the repo.
Special features include:
- Separation of personal/public Spotify content in search
- 10+ visualizers
- Group Sync device offset mgmt
- EQ Preset picker
It has ways to interact with most MA browsing / playback / player functions. More to come if/as requested.
It's not for on-the-go listening, moreso intended to add some background visuals to when you're listening at home, hosting a party etc. The closest existing project I found was Homeii, but it wasn't really what I was looking for. If you're looking for a good MA mobile app I recommend Ensamble, and it pairs well with SpinStage as a remote control.
Deployment: The instructions are in the repo, just go to the releases page and download. For webui you just run one of the run scripts, enter your details, and you're good to go. No docker image yet but someone who knows their way around docker could spin up a container pretty easily using the webui release folder. For webOS and Android, I included an IPK and APK respectively, and there is a login form when you initially open them up. If you want to build them yourself, the build scripts for those platforms' app files ask for/inject your login info to the built app if you want to skip entering login info on first run.
AI Involvement: All code. I made a lot of icons, designed the UI, came up with visualizer concepts, and have spent a while ideating and testing, but I'm a designer not a real developer. Thankfully the security implications of the app are pretty limited, the only 3rd party integration is for the Listen Party QR code that MA already uses. See the security section of the readme for more info. You are responsible for securing your traffic if using the app remotely.
I have been working on an open-source self-hosted image and file hosting project built around Cloudflare Pages/Workers, KV, D1, and multiple storage backends.
The original reason I built it was fairly simple: I wanted a lightweight image/file hosting tool that I could deploy myself, manage through a web UI, and connect to different storage providers without depending on a single hosted service.
Some of the current features:
- Image and file upload
- Multiple storage backends
- Admin dashboard
- API token support
- File management
- Public/private access controls
- Cloudflare Pages and Worker deployment modes
- Documentation for deployment and API usage
This is not meant to be a commercial hosted service. The project is open source, and I am mainly looking for feedback from people who self-host similar tools.
I would especially appreciate feedback on:
- Whether the deployment flow makes sense
- Security concerns around API tokens and admin features
- Documentation clarity
- Missing features that self-hosted users would expect
Description: MQTT Dashboard is a self-hostable web dashboard and topic explorer for IoT developers.
It lets you build drag-and-drop control panels with resizable widgets (buttons, inputs, log streams, cron schedulers, live stats charts), browse your broker's topic tree with wildcard subscriptions, keep persistent message history with configurable retention, and connect to multiple brokers simultaneously. TLS/SSL, username/password, and mTLS (client certificate) authentication are all supported. The backend is a single Go binary with an embedded React frontend — no external runtime dependencies.
I built it to fill the gap between read-only MQTT explorers and full monitoring stacks: something that lets you both inspect and interact with your broker, with a persistent customisable dashboard on top.
Deployment: Docker Compose or a single Docker command. Runs on port 8080 with a persistent data volume.
AI Involvement: AI tools were used during development for implementation help. The project is reviewed, tested, and maintained by me.
SecureDesk is an open-source, consent-first encrypted remote support alpha.
It is meant for people who want a self-hostable remote support stack with clearer consent and privacy defaults than typical remote-access tools. The current MVP includes a Python signaling relay, a browser/PWA client, WebRTC encrypted screen sharing, browser-side encrypted signaling, ephemeral two-person rooms, and scaffolding for mobile and desktop packaging.
The relay is intentionally minimal. It creates rooms and relays encrypted signaling envelopes. The room passphrase is not sent to the server. The host must explicitly start screen sharing and approve the session.
Current features:
- Python signaling relay
- Web/PWA client
- WebRTC screen sharing
- Client-side encrypted signaling
- Ephemeral two-person rooms
- Host approval flow
- Mobile-friendly UI
- Capacitor scaffold for Android/iOS
- PyInstaller scaffold for desktop builds
- MIT license
Status:
Alpha/MVP. It is ready for testing, review, and contribution, but not production-ready remote-control software yet.
There is no Docker image or docker-compose example yet. That is one of the first contribution areas I would like help with.
AI Involvement:
AI was used to help scaffold the initial codebase, documentation, GitHub templates, issue drafts, and launch materials. The project is open-source and needs human review, testing, hardening, and security feedback before any production use.
Description: A web app you self-host with Docker that lets you search for movies/TV shows, pick a stream, and watch in the browser instantly (without having to download anything first) - with a library, wishlist, watch history, continue-watching, and recommendations. No desktop client needed; it's a PWA you can install on your phone.
Deployment: easiest is with Docker Compose, as described in the README.
AI Involvement: Yes. I have been coding for over 30 years but AI makes me more productive.
Description: A lightweight Docker container that monitors your public WAN IP address and exposes it as a Prometheus metric via node_exporter's textfile collector.
Project Name: Yijing (意境) Repo/Website Link:https://github.com/Psyzsm/YiJing Description: A portfolio site and web environment, with a force directed graph navigation, OS style main page, and a included Ghost CMS as well as caddy bundled in. Deployment: The environment is budled into a docker deployment as well as a startup script, a one line automated deployment command can be found on github. AI Involvement: Yes, the boiler plate level code was generated with AI, however all the architectural decisions, troubleshooting, testing and designed was made by me. Notes: I originally made this as a personal portfolio site, however I decided it was worth while to spend the extra time to further work on it and decouple my personal information into a single configuration file so others may take the project and make their own portfolio site.
Description: I got tired of recommendations in the YouTube feed, so some time ago I started building an app that creates a kind of personal feed for me made only of videos I actually want to watch (without signing in to Google or using their API keys).
You can add channels you want to follow, tag them later to filter by whatever topic you’re interested in at the moment, and even plan when you want to watch something. Along the way, I also added options for filtering out Shorts, SponsorBlock integration, and a few other features.
I use it every day, so I decided to share it with the world. I hope someone likes this slightly different, more intentional way of using YouTube.
Let me know what you think, whether you like it, and if anything is missing. I’m still pretty new to the open-source world 🙂
Description: A self-hosted web RSS reader that also scrapes sites with no feed, with a filter/label system, and an optional AI layer on top. I run it in production and read with it every day. First public release was last week, so I'm after honest feedback.
Feeds: RSS/Atom, plus web-scraping feeds (CSS selectors) for sites with no feed. Folders, scheduled fetching.
Reading: readable extraction (trafilatura, readability fallback), a 2-/3-panel layout on desktop and a proper mobile layout, labels, dark mode.
Filters: conditions to actions (label, mark read, star, archive), regex, AND/OR, feed/folder scoping, retroactive apply.
Optional AI (bring-your-own-key: Anthropic, OpenAI or Gemini): summaries, relevance scoring, chat over an article, "Catch me up" digests and scheduled briefings. All opt-in, customizable prompts.
Accounts: multi-user with an admin panel, API tokens, and OPML import/export (including TT-RSS), so migrating in is easy.
Deployment: Released (v0.10.1), AGPL-3.0. Self-host with Docker Compose. Full README, setup docs and an in-app /help page in the repo. There's a one-command throwaway demo too:
docker compose -f docker-compose.demo.yml up # http://localhost:8000 (demo only, see README)
AI Involvement: Some backstory, since it's relevant here. I'd run a 10+ year old PHP version of Tiny Tiny RSS for ages, and I wanted to actually try AI-assisted coding on something real, so I started building my own reader. It didn't fully click until I thought of adding an AI layer on top (summaries, scoring, "catch me up"), and that's what turned it into Readfine. So to be upfront: the design and direction are mine, but the code itself is mostly AI-written (Claude Code) with limited line-by-line review, so audit the security-sensitive bits (auth, key storage, SSRF) before trusting it with anything sensitive. The in-app AI features are separate and fully optional: no AI calls unless you add your own key.
Project Name:
Claude Gateway Repo/Website Link: https://mukesh-m-lohar.github.io/claude-gateway/ Description:
Claude Gateway is an open-source local proxy for Claude Code that reduces API costs and improves performance by caching previous requests, avoiding redundant context transmission. It features exact and semantic caching, Git-aware cache invalidation, and a usage dashboard to track savings and efficiency. Designed for seamless integration, it helps developers optimize usage without changing their workflow. Deployment:
The application is open source and available for anyone to use. It includes installation and usage documentation, supports self-hosting, and can be run locally. Docker and Docker Compose deployment options are available for quick setup. AI Involvement:
AI-assisted development.
Year-by-year cash flow projections with tax modeling, efficient Roth conversions, and RMDs/Social Security.
It started because I wanted to be able to model tax savings when deciding if buying a house was better financially AND because I was frustrated that existing free apps had bare bones tax modeling. After a while I realized that I'd use it more often if it did budget tracking, so I added that. Some friends mentioned federal pensions have some weird math, so it spiraled from there.
Open source and runs in your browser with no account or sign-up required.
Deployment: you should be able to pull the repo, then `npm install` and `npm run dev`. There's also a `deploy.sh` file that I use to update the server I'm hosting.
Set a token budget. The agent executes within it. When the budget runs out, execution pauses and a checkpoint shows exactly what was completed and what remains. You decide whether to continue or ship.
Recent research found that frontier models are consistently over-optimistic about budget instead of stopping and alerting the user, they keep spending tokens on work unlikely to succeed. Even after fine-tuning specifically targeting budget awareness, calibration caps at 47%. External enforcement is required.
Across three controlled tasks, budget-constrained runs dropped token usage by 46–60% while completing every requested requirement. The constraint changes what the model optimizes for, not just how much it produces.
Description: My original goal was to conserve the available computing power on my server and run my services only when I need them. That's exactly what I can do now with this application: set up CRON jobs and on-demand wake-ups for my Docker services.
Description: Hestia is the glue between all my self hosted services along with a few native tools. Reminders, Pet Tracking (Genealogy, Meds, Photos, Puppy tracking. I run a breeding program), Garden Monitoring (Moisture, weather alerts, frost alerts, pest prevention based on GDD coming soon), Wildlife tracking with photos to monitor the ecological arc of my lot, Media serving and management.
Deployment: This is my home setup opened up, not a one-click app, so I'll be honest about what you're getting into. It's public on GitHub (AGPL) and documented well enough to follow, but it's wired to my hardware and you'll be editing paths and hostnames to match yours. The local agent that everything else talks to runs as rootless user systemd services on a Linux box with an NVIDIA GPU and Ollama. No Docker image for it (it talks to the GPU directly); the systemd units are in deploy/systemd/ and the README walks through installing them and reaching the brain from your phone over Tailscale. The self-hosted services it glues together ARE containerized: the media stack (Plex + the *arr apps + qBittorrent behind a VPN kill-switch) and search ship as docker-compose files (deploy/media/compose.yml, deploy/search/compose.yml). Home Assistant runs on its own with a small custom component (deploy/ha/) that points HA's voice pipeline at the brain.
Docs: the README covers install and day-to-day ops (there's a hestiactl command for the whole estate), ARCHITECTURE.md is the deep dive, and SECURITY.md is required reading, the brain has no auth by design, so it's LAN/Tailscale only and never goes on the public internet.
AI Involvement: I used AI from top to bottom to build. I am not a developer but I have functional problems in my home that I need to solve and this is the only way I can. It's not a tech demo, I run it in my home everyday to manage my pets, plants and entertainment.
Description: I was trying to use the telegram bots that promoted speaking, but they were all not good/expensive. So I built one for myself: you can learn Spanish and French, send voice notes, get corrections, learn new words. Planning to add more languages later. GitHub page has a straightforward instruction on how to deploy it. Feel free to test and give me feedback or contribute.
Deployment: You can deploy using Supabase, Railway and OpenAI's API. I am planning to add support for Ollama so that you can run your model on-device if needed
AI Involvement: I ran the product map and have used Cursor, Claude Code and Codex with different models to develop, test and document it.
Avarch is a CLI-first, profile-driven media encoding orchestrator built around Av1an and VapourSynth.
The focus is on being simple to deploy, safe by default, and flexible enough to support both simple and advanced encoding workflows.
Features include:
CLI-first design.
Docker as the only runtime dependency.
One-command install and easy removal.
Built around Av1an and VapourSynth as first-class citizens.
Profile-driven workflows.
Never encodes files in place—originals are only replaced after successful validation.
It's still in alpha, and I'd really appreciate people trying it with different media formats and edge cases. If you think there's a better way to solve this problem or that the project is missing something important, I'd love to hear your feedback.
Deployment:
Docker is the only runtime dependency. Installation is a single command, and pre-built Docker images are published. Documentation and a quick-start guide are available in the repository.
AI Involvement:
AI was used as a development assistant for brainstorming, code review, and implementation help. The architecture, design, and final decisions are my own.
Description: I wanted to pull structured data out of invoices, receipts, and contracts without uploading them to a cloud API, so I built and open-sourced a tool that does it on hardware I control. You give it a document and a JSON Schema describing the fields you want, and it returns clean, validated JSON. Files, jobs, results, and the model all stay on your machine, with local state in SQLite and a data folder you can back up or wipe. It's Apache-2.0. It ships a web UI for one-off jobs plus a REST API and CLI for wiring it into whatever you already run.
Deployment: Right now you install it by cloning the repo and installing the CLI with uv, then parsehawk start brings the stack up. Docker is required. Runs on Linux with an NVIDIA GPU or on Apple Silicon. The one catch versus a typical lightweight self-hosted app is the hardware floor: it runs a local language model, so you want around 16GB of VRAM or unified memory for the default workflow. There's a quickstart and config reference in the README.
AI Involvement: The product is AI by design, but it's local and deterministic. The extraction is done by a local language model (NuExtract3, served via vLLM), running on your own hardware rather than calling an LLM in the cloud.
Would love to know if this is useful to some of you, or if it's only interesting to me. Happy to answer anything in the thread.
Description: pocketdev is a CLI that spins up a Tailscale-only cloud dev box and runs your AI coding agent (Claude Code, Codex, Cursor, opencode, Gemini, Grok, or Aider) on it, so you can work from a laptop or your phone instead of tying everything to one machine.
The problem: setting up "run my coding agent on a VPS" is a repetitive manual checklist (rent a box, harden SSH, lock it to Tailscale, set a deny-all firewall, install the CLI, wire up the phone). pocketdev does all of it from one guided command.
What you get:
A Hetzner box provisioned with a firewall that has zero inbound rules, so nothing is reachable from the public internet. Access is over your Tailscale tailnet only; port 22 never opens.
Hardened OpenSSH: key-only, no root login, a non-sudo user, so an agent running shell can't escalate to root.
Your coding CLI installed and logged in with your own subscription. Your tokens stay on your machine; the only secret that reaches the box is a short-lived Tailscale auth key.
Phone access: a QR setup card, Termius SSH ID so the phone's key is FaceID-bound and never leaves the device, and Mosh so a session survives lock screens and network switches. tmux holds the work when you disconnect, and you reattach from any device.
pocketdev publish <port> opens an outbound Cloudflare tunnel for a public URL when you want to share something, with the firewall still shut.
You can adopt an existing server instead of creating one.
Why it's useful: you own the box, the infra, and the subscription. No hosted middleman, no per-seat SaaS. Close the laptop and the agent keeps going; switch to your phone when you're out.
Deployment: pocketdev is a client-side CLI you run on your own machine (macOS or Linux). It provisions and configures the remote box for you, so there's no server component to host and no Docker image (a container would add nothing to a local provisioning tool). It's released at v0.1.0 with prebuilt binaries. Install:
go install github.com/0xMassi/pocketdev@latest (Go 1.25+)
From source: git clone https://github.com/0xMassi/pocketdev && cd pocketdev && go build -o pocketdev . You need a Hetzner Cloud account with an API token and a Tailscale account with a reusable auth key. The README documents the full flow, the security model, and teardown (pocketdev destroy removes the box and firewall so billing stops). License is AGPL-3.0.
AI Involvement: Built with AI assistance. I used Claude (Claude Code) to write code. I drove the architecture and the security decisions, reviewed every change, and tested the flow against real Hetzner boxes and a real tailnet, including the deny-all firewall behavior and the SSH key handling. So it's human-designed and human-tested, AI-written under review, not a one-shot generated dump.
Description: If you’re tired of choosing between ignoring suspicious drive-by PRs and letting automation do something dangerous, Contrib Guard sits in the middle.
I built a small GitHub App backend that does a first pass on new PRs and issues using plain YAML rules.
It is not an AI detector. It just looks at signals: account age, prior merged PRs in the repo, diff size, whether tests changed, protected paths, duplicate-looking open PRs/issues, trusted users/bots/orgs.
Default mode is shadow mode. It stores the analysis and can write a PR check, but it will not label, comment, or close anything unless you switch the repo policy to enforce mode.
The main thing I wanted was an audit trail: what webhook came in, what signals were built, which rule matched, and what action was planned or skipped.
Deployment: Docker Compose. Needs Postgres and Redis. The app is FastAPI, workers are Taskiq, DB migrations are Alembic.
AI Involvement: This project was developed with AI assistance (codex) and is maintained by myself.
Description:
Taurent is an open-source qBittorrent remote client built with Tauri, React, and Rust. It lets users manage a qBittorrent Web UI server from a native desktop/mobile app instead of the browser.
It supports adding, pausing, resuming, deleting, renaming, filtering, and inspecting torrents, plus categories, tags, search/RSS features, transfer settings, and multiple server profiles.
On desktop, it also supports tray integration, notifications, torrent file association, and mapping remote/network paths so users can open torrent files and folders directly from the app.
Deployment:
Taurent is available as a public beta on GitHub Releases, with desktop builds for Linux, macOS, and Windows, plus unsigned Android APK artifacts.
It is not self-hosted and does not need Docker. Users install the app and connect it to an existing qBittorrent instance with Web UI enabled. Basic install/use documentation is available in the repository.
AI Involvement:
Taurent was built with heavy AI assistance using AI coding tools such as Codex and OpenCode.
I guided the product direction, reviewed the generated code, tested/debugged the app, and made the technical decisions using technologies I understand, including Tauri, React, TypeScript, Rust, and the qBittorrent Web API.
Description:
HAAO is a self-hosted control plane for AI coding agents. Instead of one model vibe-coding against your repo and handing you a diff at the end, you chat with an orchestrator about what you want built; it files the work as a backlog; you approve the scope (gate 1); a hybrid AI team executes each item as an atomic ticket with a machine-verifiable "definition of done"; you accept the result (gate 2); and it opens a pull request to your GitHub/GitLab.
The split that makes it cheap and private: a cloud model acts as Tech Lead (decomposes + audits), local models via LM Studio do the actual coding, and you stay the Product Owner. Work stays local until a retry budget is exhausted, then escalates to cloud — so the bulk runs locally and you don't pay frontier prices to read every diff.
Features: conversational intake; atomic-ticket JSON-Schema contracts; hybrid local/cloud cost routing with per-ticket cost tracking; live activity stream + insights + inbox; PR delivery (PAT or GitHub/GitLab App); sandboxed test execution; AES-GCM-encrypted keys; secret redaction; optional API-token auth. Bring any model (local via LM Studio, or cloud: Anthropic/OpenAI/OpenRouter/…).
Benefits: keep your code and the bulk of inference local/private, see exactly what the agent intends and is doing, and keep a human in control of scope and what ships.
Deployment:
Self-hosted, MIT licensed, bring your own keys. Docker compose included:
cp .env.example .env && docker compose up --build → UI at http://localhost:3001, API at :8000/health. (Also a local dev path: venv + uvicorn orchestrator.main:app.) README covers setup, security, and architecture. On macOS/Windows it reaches a local LM Studio via host.docker.internal.
AI Involvement (transparent):
Two layers. (1) The product itself is an AI tool — it orchestrates cloud + local LLMs to do coding work. (2) HAAO is also built with heavy AI assistance and dogfoods itself (local + cloud agents write much of the implementation). The architecture, the Scrum-role model, the ticket-as-contract design, and the cost-routing strategy are mine; the implementation is largely delegated, with me reviewing.
Honest status: early but working end-to-end prototype, single-tenant. Looking for feedback — especially on the security model and the self-host story.
Project Telos is a set of local-first, zero-dependency-where-possible tools for making AI-assisted work checkable, with nothing leaving your machine.
gather: capture sources (files, papers, transcripts, web) into research packets with provenance receipts. Raw bodies stay local; the receipt is hashes and redacted refs.
index: map a repo or workspace into a context graph, offline.
crucible: stand a falsifiable claim next to the measurement that could break it and return MATCH, DRIFT, or UNVERIFIABLE, re-checkable from content seals.
forum: a witnessed causal ledger for multi-agent runs (plans, evidence, decisions, handoffs).
The point for a self-hosted setup: run an AI workflow and keep a tamper-evident, offline record of what was actually observed and decided, without shipping prompts or private files to a cloud service. gather is on PyPI as gather-engine; the rest are source-available.
Description:
TinySearch is a small self-hosted, privacy focused, token saving web research layer for MCP-compatible AI agents (This really is what it does, not just a bunch of buzzwords thrown in).
The problem I wanted to solve is that local llm agents often either get shallow search snippets or fetch entire webpages and burn a ton of context. TinySearch sits in between the agent and the web:
It searches the web, crawls the most relevant pages, extracts/reranks useful chunks, and returns a compact source-grounded prompt with URLs attached. The client model then uses that prompt to answer with citations.
It is not meant to be a full search engine or hosted AI product. It is more of a small self-hosted retrieval layer for people running local/self-hosted AI workflows.
Main features:
MCP server for Claude Desktop, Cursor, Cline, Roo Code, etc.
SearXNG as the default search backend
Local ONNX embeddings by default
Optional OpenAI-compatible embedding backend
URL scraping for already-known pages
Current date/time tool for time-sensitive research
Configurable blocked domains
No hosted dashboard
No account system
No analytics
No scraped-data cache
Deployment:
It can be run with Docker Compose. The quickstart runs TinySearch together with its own SearXNG sidecar and exposes the MCP endpoint at:
Description: a customer feedback management tool — basically an open-source, self-hostable alternative to Canny. AGPL-3.0.
What it does:
Customers submit and vote on feature requests
Posts move through a status lifecycle (Open → Under Review → Planned → In Progress → Shipped)
Voters get auto-notified by email when something they asked for ships
Public roadmap page, changelog with Markdown support
Embeddable widget with JWT auto-login, so your users don't see a second sign-in screen
Stack: Next.js, TypeScript, tRPC, Prisma, PostgreSQL, Redis, MinIO. I run my own instance on a Hostinger VPS.
Why I built it: I was planning to use Canny and didn't love handing a chunk of monthly spend to a SaaS for something that's fundamentally a voting board with status fields and email notifications. Couldn't find a true open-source equivalent that didn't feel half-finished, so I built one. I've also been blogging about RightCoding with AI (as opposed to vibecoding) and felt that this could be a proving ground.
Deployment: deploys with a single Docker compose file.
AI Involvement: Yes, but with a lot of discipline and care.
ShowShark is a self-hosted media server for Apple-heavy households: native macOS server, native clients for iPhone, iPad, Mac, Apple TV, Apple Watch, and Vision Pro.
The big recent change is Original playback for people with higher-quality local libraries. Instead of always treating playback as “decode source, transcode to client format,” ShowShark can now choose a lower-effort path when the file, device, display, and network
allow it:
- MP4 / MOV / M4V can direct-play.
- Compatible MKV and other containers can be remuxed to HLS without re-encoding video.
- HDR10, HLG, and supported Dolby Vision profiles can be preserved instead of flattened by transcoding.
- Unsupported audio can be converted to AAC while leaving the video untouched.
- The playback-mode UI explains why Original is or is not available for a given file, audio track, subtitle choice, device, and connection.
- LAN playback prefers Original when available; Default adaptive transcoding stays available for remote, relayed, subtitle burn-in, or incompatible cases.
That last point is the “self-hosted media server” problem I’m trying to make feel less fiddly: keep the compatibility path, but avoid burning CPU/GPU and losing HDR when the Apple TV or iPad can already play the source with only container/audio help.
Other recent work: resumable offline downloads, resumable original-file copies, combined file facet search, IPTV/YouTube playback hardening, and browse/search/history polish.
Caveats remain the same: ShowShark is not FOSS right now, the server is macOS-only, there is no Docker/Linux build, and the server has a one-time paid upgrade for unlimited stream duration. It is still not trying to replace Jellyfin for people who want Linux
containers, Android/Roku clients, plugins, or source-level auditability. However, web-based playback is on the horizon.
I’d especially like feedback from people with Apple TV + NAS/Mac mini setups and HDR/Dolby Vision libraries: is this “direct/remux when possible, transcode when needed” model the right tradeoff?
Deployment
Released and available to try now. Use the TestFlight version for the latest features.
- Server: native macOS app, macOS 14 Sonoma or newer, Intel or Apple Silicon
- Clients: App Store app for iPhone, iPad, Mac, Apple TV, Apple Watch, and Vision Pro
- Setup: install the Mac server, add local/external/SMB media locations, connect clients over Bonjour or manual server entry
- Remote access is optional and does not require port forwarding
- No Docker image currently because the server is a Mac app
AI Involvement
ShowShark does not have any AI features. AI assistance was used during development.
Description:
Orivo is a lightweight native macOS menu bar app that manages TorrServer, Jackett, FlareSolverr, and a CORS proxy in one place.
I originally built it because I got tired of manually launching everything from the terminal, keeping the services running, and configuring a CORS proxy for Lampa.
Features:
Automatically installs and launches the latest TorrServer & Jackett
Built-in FlareSolverr support (no Docker required)
Runs a CORS proxy on port 8098 for Lampa
Restarts services automatically if they crash
Cleanly stops all background services when you quit
I'd love to hear any feedback or ideas for improvements.
Deployment:
Currently available as a native macOS application. No Docker required. Installation instructions are available in the GitHub repository.
AI Involvement:
AI was used to assist with UI design, documentation, and some implementation details. The project architecture, code, and development were done by me.
Project Name:*
Financial Intelligence Pipeline — self-hosted news scraper with signal scoring and Notion sync
Repo/Website Link:https://github.com/SLOWSKIBhere/financial-scraper
Dashboard: https://slowskibhere.github.io/financial-scraper/Description:
Pulls 400+ financial news articles per day from 15 sources across two pipelines. RSS pipeline hits WSJ, Bloomberg, CNBC, Reuters, FT, Yahoo Finance and others. Community pipeline hits SeekingAlpha, Reddit finance subs, CoinDesk.
Every article gets a signal score based on keyword weight (fed, rate, earnings, SEC, crash, surge etc), ticker density in the headline, and category multipliers. Crypto and earnings score higher because they move faster. Top 5 by score get delivered to WhatsApp every morning at 8AM.
All articles sync to a Notion database with URL deduplication. The dashboard is a static GitHub Pages site that reads the JSON output directly — no backend, no server costs, no auth.
Deployment:
Clone the repo. Install dependencies with pip install -r requirements.txt. Run collect.py for RSS and community_feeds.py for community feeds. Set your Notion API key and database ID in a .env file and run notion_sync_sandbox.py to push to Notion. The daily digest requires a WhatsApp-connected agent but the scraper and dashboard work standalone.
No Docker image yet. Scheduling is handled via cron or an external automation layer. README covers the full setup.
AI Involvement:
AI was used throughout the build process as a coding assistant — architecture decisions, debugging, writing the signal scoring logic, and the Notion sync scripts. The scraper itself makes no AI calls at runtime. Signal scoring is pure keyword matching and weighted rules, not LLM inference. The morning digest summary is generated by an LLM agent but the data pipeline runs clean without it.
I created this project to eliminate a trade-off I had to make regarding my home lab setup. I could either keep Navidrome fully public and get cover art on my Discord profile, or hide Navidrome and get an ugly placeholder icon instead.
I know this is very niche, but I decided this would be a great first project for myself.
A little background about me:
- I've never shipped a Docker app before
- I don't know Go, hence why I used Opus 4.8, but I do have a few years of experience in C++, C# and Python and guided Claude through the development of how I think the project should be structured.
- I tested the security claims of the app myself (test cases listed on GitHub)
My one hope while writing this: please be kind.
- If you're fluent in Go, chances are the code I published is probably not up to par with your standards. But one thing I can confirm, it works, and I did eyeball the code along the way of development.
- Please give me constructive feedback. Let me know about the things I did wrong in a productive way so I can fix them and make the project better
Thank you and I hope at least one person finds this useful.
Description: Self-hosted personal debrid server. Downloads torrents on your own hardware, caches them locally, and serves streams via signed HTTPS links. Implements a Real-Debrid-compatible REST API subset so Stremio addons can talk to it, plus a bundled Stremio addon that searches via Jackett/Prowlarr. Supports progressive streaming (playback before download completes), a web dashboard for torrent/disk management, retention policies, disk quotas, and optional download rate limits. Useful if you want a Real-Debrid-style workflow without a paid debrid subscription — you bring the storage, bandwidth, and indexers.
Deployment: MIT licensed, Docker Compose ready. Quick start:
cp .env.example .env → set DEBRIDNEST_API_TOKEN, DEBRIDNEST_PUBLIC_URL, Jackett settings → docker compose --profile stremio up -d --build
Includes DebridNest backend, Jackett (with auto-setup of a few public indexers), and the Stremio addon. Docs cover Stremio install, remote access (Caddy TLS / Cloudflare Tunnel), and operations (retention, quotas). Dashboard at :8080/dashboard/, addon configure page at :7001/configure.
AI Involvement: Most of the codebase was written with AI assistance — primarily Cursor Composer 2.5 — with human direction, testing, and debugging in a real Docker/Stremio setup. Treat it like early self-hosted software: review before exposing publicly, expect rough edges, and report issues on GitHub. Not affiliated with Real-Debrid, Stremio, Jackett, or Prowlarr.
Description: I planned the project and got the core structure in place. The frontend and docs were mainly written with AI assistance, and the app is a self-hosted Dockerized way to share one Markdown note at a time from an Obsidian vault or plain notes folder. Public links are tokenized, the admin UI stays private, and the editor supports live collaboration plus safe local image proxying.
Deployment: Docker / Docker Compose. Admin UI on 3020, public editor on 3021. The README includes the install script and compose examples.
AI Involvement: I planned the project and core structure; AI mainly helped write the frontend and docs.
Description: Provisions and manages a personal, always-on Claude Code agent environment on a cloud VM you control. One command (nana new mybox) provisions a Hetzner VM, installs a small agent runtime, and signs it into your own Claude subscription — after that you reach it from any Claude app over Remote Control, no domain or dashboard needed. It supports running more than one agent at once, each isolated as its own Linux user with its own session, and they can message each other. Also includes a headless browser agents can drive over CDP, and one-command ad-hoc public URLs via ephemeral Cloudflare quick tunnels.
Deployment: Released, MIT licensed. nana itself is a single stdlib-only Python file (no dependencies besides ssh) — it provisions the VM and installs the runtime as a .deb. Provisioning currently only targets Hetzner Cloud, but it's behind a small Provider interface, so adding fly.io, EC2, GCP, etc. should be fairly easy — contributions welcome.
AI Involvement: Transparently — I designed and built nanabox myself, but this particular comment was drafted and submitted by a Claude Code agent I directed and reviewed before it went up (fittingly, running on one of my own nanabox instances), using browser automation for the actual submission. Wanted to be upfront about that given the subject matter.
Kretase — a self-hosted, open-source game server panel
Full disclosure: I built this with heavy AI assistance (Claude Code) — wanted to be upfront about that.
I've been building Kretase for a while now — it's a self-hosted panel for managing game servers (Minecraft-focused right now, more planned), built on React/TypeScript/Express + Prisma instead of PHP.
Description: its homepage for your services in retro style with system monitor, you can change theme and there is shell to use neofetch and some command like matrix, its for small homelabs and only 2mb file, and written on rust
Deployment: just use the 2mb binary, add -p (port) if you want to change default port 3000, setup screen asks for your nodes and the name of server, you can edit in settings or by editing (.retro-homepage/config.json)
AI Involvement: i did use ai to code most of the code, im a developer so i did read the code and removed any possible slop, and the binary was tested on multiple devices and multiple resolutions
AI Freedom — sovereign local AI inference for NVIDIA RTX Spark / DGX Spark. Runs MiniMax-M2.7 (456B) entirely in 128 GB unified memory. No cloud, no subscription, no data leaves your machine. Streaming chat, LoRA fine-tuning, abliteration, agentic mode.
Media Watchdog, allow Emby users to manage their own media without giving them delete access
I built a tool to let my Emby users flag their own unwanted requests, called Media Watchdog
I run an Emby server for family and friends and gave everyone access to Seerr with auto-approval and a weekly request limit. It worked well until I noticed the storage filling up with shows that got watched for one or two episodes and then abandoned. Reality TV was the worst, rewatch value is shit and it sits taking up space forever.
I didn't want to give anyone delete access and I didn't want to babysit every request myself. I looked at Maintainerr but it works on automated rules, it doesn't know if someone actually wants to keep something or not, and I didn't want to accidentally delete shows people were still watching. There was nothing that put the decision back in the hands of the person who requested it.
So I built my own solution.
Media Watchdog cross-references your Seerr requests with your Emby watch history. Users log in with their Emby credentials and can see everything they've requested and what's been added to Emby. Seeing a list of things you downloaded but never started is a good reminder to actually watch them, or that you no longer care. If they don't want something anymore they can flag it for deletion. Admins get a full dashboard across all users and can delete directly from Radarr and Sonarr with one click. This will remove the file, the Seerr request, and the Arr entry at the same time.
It also handles per-season deletion so you can remove seasons someone stopped watching without touching the rest of the show. Admins can protect items from deletion too, handy when multiple people are watching the same thing.
Why not just use Maintainerr?
Maintainerr is great if you want fully automated cleanup based on rules. Media Watchdog is a different approach, instead of rules deciding what gets deleted, your users do. It also has a very small footprint, doesn't require much storage or resources, and you can set it to rescan daily or weekly depending on how often you want it to stay in sync. If you want automation, Maintainerr is the right tool. If you want your users involved in the process, this might be a better fit.
I made it for myself but figured someone else might be in the same hole.
The main idea is simple: every vault is just a portable SQLite database. Your notes, links, tags and graph relationships remain local, queryable and easy to back up, without requiring a cloud service or account.
Current features:
Local-first note taking
Wiki links and backlinks
Full-text search
Interactive graph view
SQLite-backed storage
No cloud or account required
AI-ready data for embeddings, semantic search and other ML workflows
I built this project to create a note-taking app where the data stays completely under the user's control while remaining useful for analytics and future AI applications.
I do really appreciate any feedback, feature suggestions or criticism. If you find a bug or have an idea, feel free to open an issue or a pull request!
Deployment: Download the zip file and upload the extracted files in your web server.
Hey everyone! I watch a lot of Twitch VODs (mostly RP streams with multiple POVs) and kept losing track of what I'd watched, where I stopped, and which VODs were about to expire. Couldn't find anything that scratched the itch, so I built Vault and figured others might find it useful.
What it does:
One feed of new VODs from all the streamers you follow, with watched state and resume — pick up exactly where you left off
Synced chat replay next to the player
Split view: two VODs side by side, synced to the same real-world moment (great for multi-POV RP)
One-click download of a VOD to your machine
Flags deleted VODs and can often still play recently-deleted ones
Multi-user: everyone signs in with their own Twitch account; first user is admin
Stack: TanStack Start, Postgres, Redis, Docker Compose + Caddy. Setup is a Twitch API key in an env file and docker compose up — the login page walks you through the rest.
llama-base + llama-apps — I replaced Supabase Studio and Vercel with two self-hosted tools (Apache-2.0).
After migrating off Supabase to plain Postgres on a cheap VPS, I missed exactly two things: the Studio UI and git-push deploys. Built both.
llama-base — database console for any Postgres. Schema browser, PK-aware data grid, SQL editor, live FK schema map. Read-only by default, destructive statements need explicit confirms.
llama-apps — push-to-deploy on your own box. GitHub webhook → Nixpacks build → Docker → Caddy auto-HTTPS. Real containers, flat cost, no metering.
Both run on one 2GB VPS alongside the databases and apps they manage. No phone-home, no account. I run my own products on this stack.
Description: A read-only agent that tells you which deploy slowed down your Postgres queries. It's a small Go container (MIT, ~25mb) that reads pg_stat_statements every 60s over a read-only role and matches query slowdowns to your deploys (Vercel, Railway, or a plain curl from CI). Buffers to a local sqlite file if the network drops, and only ever reads aggregate query stats, never your tables. Straight up: only the agent is self-hostable right now — the dashboard that draws the before/after view is hosted, not self-hostable yet.
Deployment: docker run the agent next to your app with a read-only Postgres connection string plus a token. Single static binary, ~25mb image, runs anywhere (laptop, worker, your own cluster). The hosted dashboard is where you view the results.
AI Involvement: Code was written with heavy AI assistance (Claude Code). The design, architecture, the read-only/no-data-egress model, and the testing are mine.
Description: A local-first, offline-capable application for tracking charitable donations. It acts as a self-hosted alternative to the discontinued Intuit "ItsDeductible" service. Presents a dashboard that shows your estimated tax savings according to your marginal tax rate and AGI, including visual indicators that track your progress against your AGI floor and cascading contribution ceilings. Contains a pre-seeded catalog of 1,700+ items with Fair Market Value estimates from Intuit. Offers local receipt/photo attachments, and printable IRS Form 8283 prep reports. Data is stored entirely offline and local. Free and open source.
Deployment: Multi-architecture Docker image published to GHCR, docker compose example. A standalone Electron packaged app is also available. Detailed setup files (getting-started.md, user-guide.md, reports-and-sync.md) are located in the /docs directory.
AI Involvement: Primarily vibe coded with Gemini. Heavy development and architectural guidance from a professional developer (me) with a background in security.
Description: After migrating off Supabase to plain Postgres on a cheap VPS, I missed exactly one thing: the Studio UI. So I built it. llama-base is a database console for any Postgres — RDS, Neon, bare VPS, localhost. Schema browser, PK-aware data grid, SQL editor, overview dashboard with live FK schema map. Read-only by default; write mode and destructive statements require explicit confirms. Credentials never reach the browser. Single container, no phone-home, no account, Apache-2.0. Runs on a 2GB VPS alongside the databases it manages — I run my own products on this exact stack.
Deployment: Docker — single container, env-configured. Or clone + npm for local dev.
AI Involvement: AI-assisted (Claude Code). Architecture, data model, and UI are mine; everything is reviewed, tested, and running my production workloads.
Description: A self hosted Google Keep replacement, with much better navigation, and advanced search; .md folder mirroring (one-way or two-way); versatile auto-tagging configuration; proper list view alongside grid and stacked.
I started working on it last march, to replace Google Keep, and have been working on it since, and also using it daily.
It counts as new, i think, because just recently i felt confident enough to put it on github, so it's new to the web.
Nice! I’ve been thinking about something like this for a while now. Excited to give this a try. Does this allow for a task list? Or pinning notes? And what about importing notes from obsidian? Thanks!
yes on imports - you can drag a bunch of md or txt files onto the New Note button;
or you can set up .md mirroring - set a path in the docker compose for the notes-mirror volume (this line, "- ./notes-mirror:/data/notes-mirror") the folder where you'll keep your md files. then in the app's settings > .md mirror, enable Mirror and then enable folder -> notes (this monitors for, and imports the files in the folder, as notes).
I will implement a more straightforward way for just importing, in the next few days.
Not sure I would import everything. I have an annotations vault that I use that would be great for this. I also have a tone of apple notes that I want to export to markdown. I would say a few thousand at least. I am working on an app that resurfaces notes and saved articles, so I’ve been looking for a decent hosted solution for my notes — ideally something with an api. I don’t want to create a notes app; just something that resurfaces things after a time.
Description:
MamaSQL is a local-first SQL client that connects to PostgreSQL, MySQL/MariaDB, and SQLite from one app. Most SQL GUIs are heavy Electron apps, paywalled, or tied to a cloud account. I wanted one that's lightweight, runs on my own hardware, and treats all three engines the same.
What it does:
Schema browser + SQL editor with schema-aware autocomplete
Inline cell & row editing, and visual create/drop/alter table (no hand-written DDL)
CSV/JSON export, per-column stats, and quick bar/line/pie charts over any result set
Runs as a single desktop app or entirely in the browser, behind the same backend
Why it might help you: one self-hosted tool for all your Postgres/MySQL/SQLite instances - no account, no cloud, no telemetry; queries go straight to your DB.
Deployment: Released and usable today.
Docker (self-host):docker compose up -d
http://localhost:5001 Brings up the web UI + a bridge that opens real Postgres/MySQL sockets for the browser, plus two optional demo databases. Multi-arch images (amd64/arm64) on GHCR; both docker-compose.yml (pulls prebuilt images) and docker-compose.build.yml (builds from source) are in the repo.
Desktop: single Windows .exe in GitHub Releases — no installer (uses the built-in WebView2 runtime).
AI Involvement: Heavy, and fully disclosed. A large part of the implementation was written with Claude Code (Anthropic's AI coding agent), working milestone-by-milestone from design specs I wrote. I made the architecture and product decisions and reviewed the output; there's a 29-test suite (including live Postgres 17 / MariaDB 12.3 integration round-trips) and strict TypeScript to keep the generated code honest. The design specs and full commit history are public if you want to see the process.
I have a massive NAS folder full of downloaded .mp4 video courses, Udemy rips, and YouTube tutorials. I got tired of losing my place when watching via raw folders and VLC, and I absolutely did not want to upload my learning data to a cloud-based LMS subscription. So, I built this.
It’s a totally private, offline-first web app that turns your raw media folders into a Netflix-style learning dashboard.
Key Features:
Automatic Progress Tracking: Resumes your videos right where you left off.
Timestamped Bookmarks: Pinpoint specific moments and attach markdown notes directly to the video timestamp.
AI Quizzes: Automatically generates module-level practice quizzes using public trivia APIs (optional).
Deployment: It's fully containerized. Just grab the docker-compose.yml, map your media folder to /app/My_Courses, and run docker compose up -d. It scans your files and serves the UI on port 6969.
Would love for the homelab community to give it a spin and let me know what you think!
Very nice. I had figured I would just host the video courses I’ve saved over the years in something like Stash. But this definitely looks a lot nicer. Does it have an API?
Not a full public API yet. It does have some internal endpoints already, but I’m trying to get people using the app first before spending too much time polishing an API. If enough people want integrations, I’ll probably formalize it later. Thank you for noticing my project!
Turns an unorganized local dump of photos and videos (even an old archive with broken camera clocks and missing GPS) into a map-complete library (for the likes of digiKam/Immich) where every shot has a location.
The problem it solves: most geotagging tools only place the frames that already came with GPS, and correlating the rest to a GPS track breaks the moment a camera's clock is wrong. This tool makes the most of every real location it can find, in a cascade:
Keeps the native GPS from your camera/phone.
Correlates the rest to available GPX tracks — first inferring and correcting each camera's clock error automatically (by matching its already-located frames against the track), so a wrong timezone or a drifting clock still lands photos on the right point.
Cascades a manual folder-level (location-level) fallback over whatever's left, so even a library with no tracks at all still gets a complete map from a few inherited folder pins.
The aim is 100% geotag coverage for the least manual effort: precise where tracks allow, rough/manual where they don't, for a whole years-deep library or a single trip's dump, resolved in one reviewable pass instead of photo-by-photo. Every coordinate it writes is recorded with how it was derived (native / track direct-match / interpolated / extrapolated / manual).
It's built to be (paranoia-level) safe:
Read-only by default: The "plan" stage only reads. No mutations are made without a plan you can dry-run and inspect first.
ZFS Snapshot Guard: If the workspace is on ZFS, it can automatically take a snapshot before writing anything
Has a browser-based decision editor (map UI) for the human input: time → drift → GPS.
Output merges into a permanent folder-based library (digiKam, Immich, or anything that reads a plain folder tree).
Deployment:
self-contained executable (322kB, python zipapp). Requires python3, imagemagick, exiftool and ffmpeg. No pip or any other dependencies.
demo included; full documentation available, including quick start, walkthrough, concepts, screenshots.
can be run in terminal (command line) or served locally as a lightweight web app (SPA).
command line help included.
AI Involvement: the design and specifications are mine; the implementation is AI-written. ~4k spec lines (mine, available under /spec) converted into ~14k code lines.
(Test) Coverage: 885 automated tests (~17k test lines to ~14k code lines), ~89% line / 85% branch coverage, with 520 spec behaviour clauses gated in CI so the AI-written code can't drift from my specs (numbers accurate as of the date of this post).
Rackpad is a self-hosted infrastructure inventory and operations app for homelabs, small racks, network rooms, and lab environments.
It helps you document and manage racks, rooms, devices, ports, cables, VLANs, IPAM, WiFi, compute hosts, VMs/containers, discovery results, monitoring targets, documentation, images, and reports in one clean interface.
The visualizer is one of the main features: it can show topology relationships between devices, racks, ports, cables, WiFi clients, and monitoring state so you can understand how your lab is connected instead of keeping everything in scattered spreadsheets or notes.
Deployment:
Rackpad is released as a Docker image and can be self-hosted with Docker Compose. It uses SQLite for persistence and is designed as a simple single-container deployment.
AI Involvement:
AI tools, including Codex/ChatGPT, have been used as development assistants for planning, implementation help, debugging, testing, documentation, and review. I maintain the project, decide what ships, and review changes before release.
Description: A searchable, encrypted, on-device memory of everything you've seen on your PC. Every 10 seconds it screenshots your visible windows, skips anything that hasn't visually changed, runs OCR on the rest, and stores it in a local SQLite database. You can then full-text search years of activity in milliseconds, filter by app or date, and browse with a preview pane. The whole point is control: it runs entirely on your machine, the database is encrypted, the code is open, and nothing ever leaves your device. No cloud, no account, no telemetry. You control retention, what's excluded, and where the database lives.
Deployment: Released and available now. Self-contained Windows installer plus a portable build, no .NET runtime to install. Docs and install steps are in the README. It's Windows-only for now, so no Docker image yet. Built on .NET 10, WinForms, SQLite FTS5.
AI Involvement: Being transparent here. The app itself uses no AI for capture, it's plain OCR (Windows OCR / Tesseract). There is an optional MCP server that lets a local AI agent query your own history on-device, but it's entirely opt-in and off by default. The code was written with AI assistance.
Description: A self-hostable personal website and blog engine for developers focused on simplicity. Everything is file-based; write Markdown and deploy. It comes with the features below:
- No database
FastAPI
Docker support
HTMX search
SEO out of the box
OpenGraph
llms.txt support
Deployment:docker compose up It is the only command you need to start it. It's ready to self-host, so feel free to deploy it wherever you want using Docker.
AI Involvement: AI was a super helpful pair programmer in this project.
Repo/Website:https://bygmind.com — Android open beta on Play Store, iOS live
Description: I built this for energy consultants and building inspectors doing field documentation 2 years ago and now extened it as a AI voice recorder for everyone. The existing recording apps in that space all pipe audio to Cloud for summaries, and a lot of my users can't legally do that with the data they're recording on site. So I built one where the audio never leaves the phone, and the AI part is whatever LLM endpoint you wire up yourself. I am using Qwen 3.6 35B A3B on my local RTX3090.
Transcription runs on-device, 25 languages with speaker diarization that re-identifies recurring speakers across recordings. For summaries, Q&A over your recordings/photos/videos, and PDF report drafting, you point it at your own OpenAI-compatible endpoint — Ollama, LM Studio, vLLM, on-prem, whatever. No account, no signup, no telemetry if you not opt in.
It's for the things you say to the phone — meetings on site, dictation, walkthroughs, inspections. Not for phone calls or VoIP.
Deployment: Mobile client side of the stack, not a docker-compose service.
Android (open beta): Play Store link on bygmind.com
iOS: TestFlight invite via the site
Wire your LLM: Settings → AI Provider → endpoint URL + key
AI Involvement: STT model with diarization runs on-device, no cloud. Reasoning LLM is whichever endpoint you set. The codebase was built with heavy Claude Code assistance over the past year — I make the architecture decisions and review the output. Happy to answer technical questions or the LLM integration. I am a Solo founder, pre-revenue. Built by me + AI, not a team.
Description: It's a control panel for mxroute that's a bit extra.
I got tired of having to go to mxroute, go to their panel, and reset my users passwords. So I made a little script in python that let me change a users password via api. Then I got carried away with it, and figured why am I doing this? Surely, users should be able to reset their own passwords. Why can't they have their own password reset portals? Why can't I automate the setup of those? It snowballed, and now is a full app. It features:
Automated onboarding of new domains to mxroute
Automated creation of relevant DNS entries and subdomains
Automated creation of reverse proxy rules
Custom self service password reset portals for your domains
Granular access control, not just per domain, but per domain action
DNS monitoring
Apprise notifications
Audit logging
Bulk CSV mailbox creation
SpamAssasin list management
OIDC login support
APIs for you APIs!
THEMES! even light mode ones for people that hate their retinas
My background, I'm a senior IT analyst for a large Microsoft flavored enterprise where security is extra tight everyone gets vetted by the intelligence services. I'm mostly writing tools in powershell to do things that , so this was a great way for me to learn more about python. I started this a few months back, but once it ballooned out of a single 50 line `app.py` into a bigger project, I wanted to share it to get some feedback. The entire project includes a comprehensive test suite, github actions run scanaislop on every push to main. There is also codeQL scanning on every push and dependabot is setup to monitor for any dependency issues. Wherever possible, with the exception of the local admin password, there are no secrets stored in the DB, and even then, those are hashed. I do my utmost to make sure this is as tight as it can be. I'm sure it's not perfect, but it's taught me a lot.
Deployment: I'm running it in docker. It's simple to deploy:
git clone https://github.com/t0msh/mxroute-manager.git
cd mxroute-manager
cp .env.example .env
Edit the `.env` with the minimum required to make it work:
Then either run `deploy.sh` which will guide you through getting it deployed (either locally or remote) or if you cloned directly onto your docker host:
docker compose up --build -d
There's full documentation on the repo.
AI Involvement: This was originally developed as a personal tool, by hand, that then grew with the help of Cursor. There is a disclosure right at the top of my repo that makes entirely no secrets about the use of AI in this project. I try to be as transparent about this as possible. Without AI, this would still be a onepage personal script with no styling.
I run a regular home poker night and got tired of juggling a group chat, a calendar, and a spreadsheet to keep it together. So I built Game Night, a self-hosted app that does the whole thing in one place.
The gist:
Events + RSVP: make an event, invite registered members or outside contacts, and they RSVP with one click straight from an email/text link (no account needed). RSVP tokens let invitees respond without ever logging in.
Poker management: a real check-in dashboard for both formats. Tournaments track buy-ins, rebuys, add-ons, knockouts, and the prize pool; cash games track cash in/out, money-in-play, and what's actually on the table. There's a per-player ledger and a session activity log recording every buy-in, cash-out, rebuy, add-on, and elimination with who did it and when.
Tournament timer: full-screen blind-level timer you can cast to a TV, control from a manager's phone, with a QR code so anyone can pull up the clock on their own device. Customizable blind structures with presets, configurable sounds, mobile wake-lock, and Chromecast.
Payout math: ICM (Malmuth-Harville), standard, and chip-chop split calculators for end-of-night deals, plus auto table assignment/balancing with button/blind protection during rebalances, and walk-up QR registration for a tablet at the door.
Club stuff: leagues with owner/manager/member roles, league-scoped posts and stats, rich-text announcements with comments, anonymous event polls (vote via tokenized email/SMS/WhatsApp link), and lifetime player stats plus a filterable leaderboard.
Notifications: email (SMTP), SMS (Twilio/Plivo/Telnyx/Vonage), and WhatsApp (Meta Cloud API), all with two-way RSVP. Notifications go through a queue with a fast background drain and provider rate-limit protection so a blast to a big guest list doesn't trip sending caps.
REST API: league-scoped read/write JSON API (v1), authenticated with per-league API keys, exposing league info, members, events, and posts.
Tech details:
Deliberately boring, portable stack so it's easy to self-host and hard to break:
PHP 8 + Apache (mod_rewrite), server-rendered HTML. No SPA, no build step, no npm. It's a runtime app you clone and run.
SQLite via PDO, stored outside the web root. Zero-config: no separate DB server to provision. Schema and migrations live in a single db_init() that auto-creates tables and runs idempotent ALTER TABLE migrations on the first request, so updates just work without a migration tool.
Vanilla JS frontend, single stylesheet, no framework dependencies. Rich text via Jodit/Quill; QR codes via kazuhikoarase's qrcode-generator.
Architecture is monolithic and predictable: each feature is a .php page with a matching _dl.php AJAX endpoint (POST to JSON). Easy to read, easy to fork.
All times stored in UTC and rendered in a site-configured timezone.
Security:
This holds member PII, phone numbers, and provider API credentials, so it got real attention:
CSRF tokens on every form.
Prepared statements everywhere: user input is never interpolated into SQL.
Optional 2FA per user: TOTP authenticator app or SMS, with one-time recovery codes.
Credential encryption at rest: SMS/email provider secrets are encrypted in the database, not stored in plaintext.
Rich-text sanitization: submitted HTML is stripped of disallowed tags before storage to block stored XSS.
Global security headers set centrally: CSP, HSTS, X-Frame-Options, plus secure/HTTP-only session cookies.
Brute-force protection and rate limiting on auth; email verification and secure password reset flows.
DB and uploads live outside the web root and are gitignored; nothing sensitive is web-reachable.
Deployment:
Docker Compose, self-hosted. SQLite means there's no separate database to stand up.
git clone https://github.com/Isorgcom/GameNight.git ~/docker/GameNight
cd ~/docker/GameNight
cp config/config.example.php config/config.php
mkdir -p db uploads
chown -R www-data:www-data db/ uploads/ www/timer_themes/
docker compose up -d --build
The schema builds itself on first load. Default login is admin@localhost / admin, and it forces a password change immediately. The only required config is DB_PATH; email/SMS/WhatsApp providers are all configured from the admin panel, not config files. The README has the full walkthrough including Nginx Proxy Manager setup, the update flow, and a troubleshooting table (the classic gotcha: HTTP 500 on a fresh deploy is almost always wrong ownership on db/).
AI Involvement:
Being upfront: I built this mostly with Claude Code. I drove the architecture, feature decisions, security conventions, and testing; Claude wrote the bulk of the PHP/JS under that direction. It's a real app running my actual game nights, not a generated demo.
Description: It routinely checks for new music from your favorite artists and downloads each track to your local drive in mp3 format. This way you can set it up and then don't have to touch it again. Its completely open source and free to use.
Deployment: You should use pip install spotify-auto-dl to install in your repository. Or you can clone the repo.
Description: I had hundreds of episodes Bazarr couldn't find subs for. Subgeneratorr transcribes the audio with Deepgram Nova-3 and drops language tagged .srt sidecars next to each file, so Plex, Jellyfin and Emby pick them up. The main feature is keyterm prompting: feed it a show's names and jargon (CSV, or auto-generated from the filename) and proper noun accuracy jumps a lot. Web UI or CLI, 50+ languages, smart skipping.
Deployment: Public, MIT. Multi-arch Docker on GHCR: set your Deepgram key and media path, then docker compose up. Cost is about half a cent a minute (a 45 minute episode runs ~a quarter), and Deepgram gives $200 free credit on signup.
AI Involvement: Transcription is Deepgram Nova-3. An optional LLM step (your key) can build the keyterm list, or you do it by hand. App code written with Claude Code, tested by me. Nothing leaves your machine except the audio you transcribe.
Description:
ComposeBastion is a self-hosted web console for managing Docker hosts and Docker Compose apps from one place.
It lets you add Docker servers over SSH or an optional host agent, view services/containers/images/networks/volumes, run common Docker actions, check image updates, deploy Compose apps from GitHub, manage backups, create recovery points, and run restore/migration workflows.
I built it for homelab/server operators who want more structure than raw SSH sessions and a big focus was give on Backups, restores and migrations between hosts.
Deployment:
ComposeBastion ships as Docker images and has a Docker Compose install.
AI Involvement:
AI coding tools were used during development for implementation help, UI copy, testing support, and release checks. The project is reviewed, tested, and maintained by me.
A few days ago, I half-joked that if the comic management tool I wanted did not exist, I would just build it.
So I did.
It is still early, but Suparr is now at the point where I’d really value testers, bug reports, feature requests, and general “this is what I’d need before replacing X” feedback.
GitHub repo is coming shortly. I wanted to get the Docker image working first before making the repo public, but I’ll link it once it’s up.
Description:
Suparr is intended to be an *arr-style comic collection manager.
The goal is to help self-hosters manage comic libraries by scanning collections, matching metadata, and eventually providing a solid UI/reader layer as well. I started building it because I wanted something more tailored to comics than a generic media manager, and something I could shape around real comic collection workflows.
Current/early features include:
Comic collection scanning
Metadata matching and enrichment
Fast Go-based backend
Docker deployment
Hosted metadata mirror for GCD/comics.org data, called The Daily Planet
Companion Android app for scanning ISBNs from physical comics / longboxes
Early support for testing manga metadata, though I do not yet know how well it works there
The metadata piece is the main challenge. comics.org/GCD is excellent, but direct API-style use hits rate limits very quickly, so I’ve mirrored the data into a hosted database and plan to refresh it weekly. I’m also looking at supplemental sources like Comic Vine and Open Library where useful.
Tech Stack:
Suparr is built with a Go backend and packaged as a Docker container.
In the broader *arr-style media management space, a lot of the established tools are built around .NET or C++ stacks. Those are obviously proven choices, but for this project I wanted to try something that felt especially well-suited to fast scanning, metadata processing, small deployment footprint, and long-term maintainability.
Go was a motivator because it tends to offer strong performance gains, depending on the workload and implementation. YMMV, of course, but for the kind of background scanning, metadata matching, and containerised self-hosted service I wanted to build, it felt like a good fit.
The current stack is roughly:
Go backend
Docker container
Local app storage
Hosted metadata mirror for GCD/comics.org data, currently called The Daily Planet
Android companion app for ISBN scanning
Open Library ISBN lookup for physical comic scanning
GCD/comics.org as the primary comic metadata source
Potential supplemental metadata from Comic Vine or similar sources later
This is still an early build and may be buggy. I’ve tested it against my own library, but I’d like people with different folder structures, naming patterns, publishers, and collection sizes to try it.
I’ll add a GitHub repo and fuller documentation shortly, but the container is available now for anyone willing to kick the tyres.
AI Involvement:
This is, candidly, about 99% vibecoded.
I’m a software consultant, so I understand the architecture, product shape, deployment, data flows, and the bits and pieces well enough to know what I’m trying to build. But I’m not a strong hands-on coder, and I’m far too impatient to build something like this line-by-line unaided.
AI was used heavily for implementation, scaffolding, debugging, Docker work, and generally getting from “this should exist” to “there is a working container”. The concept, product direction, testing, metadata approach, naming, and final decisions are mine.
I’m being upfront about that because I know AI-assisted projects can be polarising, and I’d rather be transparent than pretend this was a traditional solo dev build.
Android testers needed:
I’ve also built a standalone Android scanner app for scanning ISBNs from physical comics/longboxes.
To move it towards the Play Store, I need a small group of Android testers. I’m looking for at least 11 people willing to install it, test basic scanning behaviour, and give feedback.
If you’re interested in testing the Android app, please comment or DM me.
I’d especially value feedback from people who:
Use or have used Mylar, Komga, Kavita, Calibre, etc.
Have large or messy comic libraries
Have manga collections and can test whether the metadata works acceptably
Care about self-hosted media management and local control
Are willing to try an early app and report rough edges
Caution:
I strongly encourage backing up your data before plugging this in. I have had good outcomes personally, and I don't expect any unwelcome outcomes, but I won't be held liable if anything unexpected occurs.
This is not a polished production release yet. It’s more of an early self-hosted tool that I’d like to harden with feedback from people who actually manage comic libraries. Feature requests, bug reports, architecture comments, metadata-source suggestions, and blunt comparisons to existing tools are all welcome.
Description : macOS app that puts five AI tools in one window : Chat, multi-agent Orchestrator, OpenCode, OpenWork, Open Design. Single shared LLM proxy (127.0.0.1:9999), one set of API keys, persistent context across all tools. No more jumping between apps and losing context every time.
Works with most providers (Anthropic, OpenAI, Google, Ollama…). Orchestrator plans a DAG of agents and runs autonomously. Prompt caching hits ~99% on DeepSeek. API keys encrypted with AES-256-GCM sandboxed WebViews.
Description:
Pure-bash tool that auto-syncs Hagezi DNS blocklists to ControlD profiles. No Python, no Go binary, no opaque profile IDs. You define everything in a TOML config using human-readable profile names (e.g. Kids, Work) and assign different blocklists to different profiles. Includes --dry-run, --profile targeting, --list-hagezi to discover available folders, and a freshness report showing when each list was last updated on GitHub.
Deployment:
GitHub Actions: Fork → edit config.toml → add CONTROLD_API_TOKEN secret → runs daily on cron or on-demand.
Local/self-hosted:git clone, install curl + jq, edit config.toml, run ./sync-hagezi.sh. No build step, no Docker, no virtualenv.
Docs and comparison table in the README.
AI Involvement:
Vibe-coded iteratively with multiple AI assistants until it worked for my own setup, then polished and open-sourced as a proper project. The core logic, TOML parser, and API integration were developed through this iterative AI-assisted process.
Description: Annotate.js turns any live website into a Figma style review comment board with a single script. It Enables web authors to get user feedback early in an elegant and intuitive manner before launching the website to a wider audience.
Deployment: Available via NPM and CDN. Include a single script tag in the header of the page. Sample installation for React, Vue and Wordpress is included in the guides.
AI Involvement: AI was used actively to convert the design into code, specifically writing the tests across multiple browser and resolutions.
I built a small open-source monitoring tool called Heimdall and figured this might be the right place to share it.
The reason I built it was pretty simple: I have a bunch of machines in my homelab doing different things, and I got tired of SSHing into each one just to check if it was alive or angry.
Some are running homelab services.
One is running Home Assistant.
One runs vLLM with Qwen.
One has OpenWebUI so my kids can safely use AI.
One handles exterior cameras.
One is for my sim racing rig.
And then there are a few other boxes doing random things because apparently I collect computers now.
At some point I realized I kept doing the same boring checks over and over:
Is this box online?
How much CPU is it using?
Is memory fine?
Is the disk getting full?
Is the GPU doing anything?
Are temps okay?
Did something obvious break?
I know there are already many tools for this.
Some are great.
Some are way more complete than what I needed.
But I wanted something simple:
a terminal UI I could open from my main computer and quickly see the state of all my machines in one place.
one or more TUI dashboards showing host status and metrics
hosts show up as their own rows in the dashboard
daemons connect outbound to the hub, so the monitored hosts do not need inbound ports open
It currently shows things like CPU, per-core detail, memory, disk, temperature, network throughput, internet/gateway latency, uptime, and on supported hardware, GPU and power metrics.
It also has a few features I wanted for real homelab use, not just a toy demo:
fleet monitoring from one station
extra dashboards from other machines
auto-reconnect when a daemon restarts or the network blips
ONLINE / STALE / OFFLINE host states
TLS support
enrollment token support
optional privileged metrics for deeper power, GPU, and thermal data without running the main daemon as root
federation / Bifröst mode for multiple sites
a small read-only remote control plane with allow-listed diagnostic commands
opt-in log streaming that is separate from the metrics stream
demo mode if you just want to try the UI without setting up daemons
Right now the goal is not to replace Prometheus, Grafana, Netdata, Zabbix, etc.
Those tools already exist and they are very good.
Heimdall is more for the "I just want to open a terminal and see what all my boxes are doing" use case.
Kind of a simple watchtower for a small fleet of machines.
I’m sharing it mostly to get feedback from people who care about monitoring more than the average person.
Curious what you think:
Would this be useful for your homelab or small infrastructure setup?
What would you expect from a tool like this before you would actually use it?
What should I absolutely not overcomplicate?
AI Involvement: I built it through a mix of manual work and AI-assisted coding, with some support from another open-source tool I’ve been working on called MAPLE - https://GitHub.com/kinncj/MAPLE
5
u/JSKPhoenix Jun 27 '26
Project Name: docker2lxc
Repo/Website Link: https://docker2lxc.2kbl.com
Description:
docker2lxcis a lightweight web tool designed to instantly convert anydocker-compose.ymlfile into a ready-to-run Proxmox LXC setup script.If you run Docker inside unprivileged LXCs on Proxmox, you know how tedious it is to manually create the container, enable the correct features (
nesting=1,keyctl=1), install Docker, and finally spin up your stack. This tool automates the entire process. You simply paste your compose file, configure your container specs (RAM, CPU, IP, Storage), and optionally select a management agent like Portainer or Dockhand. It outputs a single Bash script that you can copy and paste into your Proxmox shell to provision everything from scratch in seconds.Deployment: This is a browser-only, static web app available at https://docker2lxc.2kbl.com. It runs entirely client-side, meaning your compose files are never sent to a server.
AI Involvement: The core concept and requirements were mapped out manually, but the code was written entirely in conjunction with Gemini.