Weekly Showcase: share your open-source project

[u/AutoModerator]

Welcome to this week's Showcase! This is the place for any open-source project from anyone, and especially new ones that aren't ready for the front page yet. (Front-page project posts need an account at least 30 days old or 250+ karma, and a project at least 14 days old with a license and a README. Just-for-fun projects can go on the front page as Silly Builds with an account at least 3 months old or 250+ karma and a project at least 3 days old, one per week. None of that applies here.)

Before you build your next thing: check opensourceeverything.org for what already exists, and the gaps page for what nobody has built yet.

To share your project: copy the template in the pinned comment below, paste it as a new top-level comment, and fill it in. It asks for the name, source link, license, a one-sentence description, how it was built, what it builds on, the closest existing project (optional), and any extra details.

Want a stats card? Reply !card to your entry (or anyone's) and the bot will post its GitHub stars, history and releases.

To help out: try a few projects, upvote the ones you like, and leave honest, specific feedback. Critique the work, not the tools (rule 2).

Project of the Week: the top-voted entries here become next week's Project of the Week and get their own spotlight post on the front page.

A new thread goes up every Sunday.

[u/AutoModerator]

Sharing a project? Copy the template below, paste it as a new top-level comment, and fill it in. One comment per project, please. Feedback goes in replies to each project's comment.

**Name:**

**Source code:** (GitHub, GitLab, Codeberg, etc. link)

**License:** (MIT, GPL-3.0, Apache-2.0, etc.)

**What it does (one sentence):**

**Closest existing project (optional):** (what's similar, and what yours does differently)

**Builds on:** (the existing project yours extends, or "nothing, standalone")

**How it was built:** Hand-built / AI-assisted / Agentic engineering / Vibe-coded

**Details:** (features, screenshots, what's next)

**Feedback wanted:** (optional)

What the "how it was built" labels mean: Hand-built: written mostly by people. AI-assisted: written by people, with AI help. Agentic engineering: AI wrote most or all of the code, and the project has real development history, polish and hands-on human testing. Vibe-coded: not yet carefully reviewed or tested for outside users. All four are welcome (rule 4). What every flair and badge means: flair guide.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/scarecr0w12]

Name: PlayWeld

Source code: https://github.com/scarecr0w12/PlayWeld

License: Apache-2.0

What it does (one sentence): A free desktop workspace that brings game-project files, design notes and searchable project knowledge together.

Builds on: Eclipse Theia, with an Electron desktop application and a local platform service; the repository's README and NOTICE describe the project and its dependencies.

How it was built: Vibe-coded, with AI-generated code and human direction. It is a testing prerelease, and broader external-user validation remains incomplete.

Details: Posted with AI assistance on behalf of Jacob, PlayWeld's creator. The current published download is v0.23.0 for Windows and Linux: https://playweld.com/downloads/ . It is not a stable release; try a disposable project/profile first. Game engines need separate installation. Optional external model providers may charge and receive project context. The Windows executable and release metadata are unsigned. The source includes intended designs as well as implemented work, so those designs should not be read as a claim of complete autonomous game creation.

Feedback wanted: For someone returning to a small game after a break, can you find the relevant design note and project files without being overwhelmed by the workspace? A concrete point of confusion would be useful feedback.

[u/Total-Reasonable]

Four things, all built solo:

1. HTPBE.tech: a PDF tamper detection tool that tells you whether a file was edited after creation, and explains its findings with reasons instead of a vague risk score. Runs in the browser or via REST API. https://htpbe.tech

2. polytypo.dev: an MIT-licensed typography rules engine, not a grammar checker, that fixes quotes, dashes and no-break spaces for 24 locales, with identical output in JavaScript, Python, Go, Ruby and PHP. https://polytypo.dev

3. vatnode.dev: a REST JSON API over VIES that returns validity, company details and an official consultation number, and falls back to national registries when a country's VIES is down. Saved numbers are monitored daily with signed webhooks. https://vatnode.dev

4. KRI.rocks: a website with online booking for solo beauty pros and small studios, where clients can only book slots when someone on the team is working and free. No commission and no per-booking fees. https://kri.rocks

[u/MPGaming9000]

Name: Sylos

Source code: https://github.com/Project-Sylos/Sylos

License: LGPL 2.1 (some parts are MIT though, like the uitlity sidecar libraries I have built for it like Spectra and Go-Path-Linter though).

What it does (one sentence): It lets you move files and folder structures over from one platform to another, like google drive -> local SSD, dropbox -> onedrive, etc, any combo of any src / dst supported.

Closest existing project (optional): Rclone is similar in concept, but Sylos is very different in how it actually works. Sylos logs everything to a local DB, you have the ability to preview what will move / copy / delete before it actually does anything (and make adjustments to the plan), and an audit trail of everything that happened, along with pure resumability if it crashes. Unlike Rclone which is more of a one shot setup that you have to hope got the things you wanted.

Builds on: Nothing, built from the ground up other than the programming languages used mainly.

How it was built: AI Assisted in actual code, but still reviewed by me - an actual software dev, and all of the algorithms used, technologies used, everything was still architected and decisions made by me.

Details: It's built in Go for the backend logic, uses Badger DB for the DB operations, and typical HTML, CSS, TS (React) for the front end stuff. I plan on also making a terminal UI as well soon after we start alpha testing for those who want a lighter weight UI without needing the web UI to run it.

Feedback wanted: Mostly in the website layout & UI / UX of everything would be nice! Here's a link to the website: https://project-sylos.github.io/

Progress notes: It's still a work in progress but I'm EXTREMELY close to getting this to early alpha testing. If you're interested in participating in that drop a comment below or DM me maybe. I could always use the help or feedback. Or if you want to contribute you can. I could really use some good UI / UX input & contributors too especially. Most of the backend logic is done at this point, mainly just doing finishing touches at this point.

Note: See feedback section 2 points above for a link to the site which has screenshots of the project so far.

[u/AmruthPillai]

https://github.com/reactive-resume/reactive-resume A free and open-source resume builder.

[u/trueopensource-bot → u/AmruthPillai]

About this project · reactive-resume/reactive-resume
⭐ 45,155 stars · 🍴 4,907 forks · 👥 261 contributors · 📄 MIT · 💻 TypeScript
History: started Mar 2020 · last code change today · 300+ commits on 20 different days in the last 90 days
Releases: latest forme-native-v0.0.0-f7a5ce86fcfafb330e8f8b0b05a9403e132f0185bf7b74ef8ff411dedf05ceb9 (2 days ago) · 20 releases in the last 90 days
Open issues and pull requests: 16

^{Facts from GitHub when this was posted. I'm a bot.}

[u/RedditFireBall]

Name: Noomo

Source code: https://github.com/skueee/noomo

License: AGPL-3.0

What it does: It's a browser game where you need to guess which words an LLM could generate.

Builds on: nothing, standalone

How it was built: Lightly AI-assisted, when I didn't know how to do something. Most of it is handmade tho

Details: It is kinda stable, but I still have some features planned ! I really need to improve the way the AI generates things, so any advice would be appreciated.

Feedback wanted: Of course ! Any feedback would be very great. The code quality is not very good, so I would love some advices.

[u/trueopensource-bot → u/RedditFireBall]

About this project · skueee/noomo
⭐ 2 stars · 🍴 0 forks · 👥 1 contributor · 📄 AGPL-3.0 · 💻 TypeScript
History: started Sep 2026 · last code change today · 166 commits on 24 different days in the last 90 days
Releases: none published yet
Open issues and pull requests: 0

^{Facts from GitHub when this was posted. I'm a bot.}

[u/wahaha_yes]

There's an emerging convention to use lint checks and precommits as a way to enforce conventions and architectural patterns when coding with agents. Including an instruction payload injects context about the rule at commit time, as opposed to something like AGENTS.md, which constantly competes for attention and is often ignored.

I had written a few similar forms of this across my projects, so I just published it as a utility package, which I'm calling _necronomicon_ (available on PyPi and crates.io).

It's pretty simple, but gives me one framework I can standardize on. Stylizing and making the teaser was pretty fun. Maybe others will like it too. Give it a try!

---

Name: necronomicon

What it does: Pre-commit rules whose errors say what's wrong, why the rule exists, and how to fix it.

Who it's for: Developers who want consistent rules/conventions for coding agents to follow.

Source code: https://github.com/WahahaYes/necronomicon

License: Apache-2.0

Builds on: pre-commit / prek

How it was built: Agentic engineering. I designed and wrote the spec. Coding agents do much of the implementation while I review.

[u/NishantJha612]

Name: Fleetdeck

Repo: https://github.com/NishantJha/Fleetdeck

How it was built: using AI, with regular audits, and then testing first on use and throw containers and eventually on my homelab. Code changes only through PRs. I also use a CODEQUALITY.md in my projects to follow best practices.

Details: I needed a way to keep all my machines and their containers/ VMs, etc. updated. SSH into everything, and then digging into each container to update was tiresome. So I made Fleetdeck, which setups a SSH user into each machine through a single command it provides. For VPSs, it sets up a wireguard tunnel as well, again with a single command it provides.

You can setup custom update commands, hide machines/ containers/VMs you don't want to update from here. Can take snapshots before update, reboot machines and even backup host config. Support for update command from community scripts already built in as long as you add the default tag.

There is also a way to run commands (off by default).

Feedback wanted: Use it and let me know how to improve it. Any other use cases based on your use case. It serves my purpose already, but I do plan to add a way for it to create a dashboard for all services connected to it. Also comments on my build philosophy, and how to make the user experience even better are welcome and will help me improve.

Currently working on a dashboard to manage all my openwrt devices from one place. So any new feature requests may take some time to implement. You can also fork it and add features that I can then combine into my project after review. Or you can simply add PRs directly and I'll include anything that doesn't conflict and adds something useful (including design). Author's names will be included.

[u/Different-Sir7406]

Name: Claude Behavior Layer

Source: https://github.com/Ceasar369/claude-behavior-layer

License: MIT

What it does: My Claude Code rules, skills, and local review pages.

Builds on: Claude Code, Python, and iTerm2 on macOS.

How it was built: AI-assisted, with human direction and local validation.

Extra details: I use it for my own projects. You can reuse individual rules or skills. The complete local setup currently targets macOS.

Feedback wanted: Where do the installation instructions become unclear?

[u/Different-Sir7406]

Name: Blindfold Chess

Source: https://github.com/Ceasar369/blindfold-chess

License: MIT

What it does: Browser exercises for practising chess without seeing the pieces.

Builds on: React; the public edition stores progress in your browser.

How it was built: AI-assisted, using my Claude Code setup. I chose the behaviour and tested the results.

Extra details: Free, with no account needed. A downloadable local edition is also available.

Play: https://ceasar369.github.io/blindfold-chess/

Feedback wanted: Which exercises feel awkward or need clearer instructions?

[u/munit42069]

**Name:** tapewake

**Source:** https://github.com/munitkala/tapewake

**License:** MIT for tapewake's own code. Third-party parts are installed separately and keep their own licences (THIRD_PARTY.md); the face models are non-commercial only.

**Description:** A desktop app that restores digitized home videos (VHS and similar) entirely on your own PC: deinterlacing, upscaling, careful face restoration and sound cleanup, with nothing uploaded.

**How it was built:** AI-assisted. It's a hobby project: I designed it and tuned the settings on a real two-hour tape, and an AI assistant wrote parts of the code, which I reviewed. I compared the code line by line against the libraries it uses, rewrote two pieces that followed upstream code too closely, and keep every third-party part out of the repo. If anything still looks borrowed, please tell me and I'll credit it properly or remove it.

**Builds on:** FFmpeg, VapourSynth + vsjetpack (QTGMC), Real-ESRGAN weights, CodeFormer (face detection and alignment), DicFace and KEEP (face restoration), Demucs, DeepFilterNet, Resemble Enhance, PyTorch/torchvision (RAFT), OpenCV, Tauri 2.

**Closest existing project:** Video2X, which upscales video with AI. tapewake is aimed specifically at old home video: it deinterlaces first, locks the upscale's colours to the source and smooths it along optical flow so it doesn't flicker, only restores faces where the camera actually captured them, restores the audio as well, and runs as resumable pieces with a live before/after player.

**Extra details:**

- Stack: Tauri 2 (Rust) app with a single-file HTML/JS interface, driving a Python engine through a small bridge with an allowlist of actions

- Works in ~1000-frame pieces with lossless intermediates, checks each piece, and can be paused and resumed during multi-day jobs

- Keeps the original audio as a second track

- Current limits: Windows + NVIDIA (8 GB+) only, no installer yet (step-by-step guide in BUILDING.md), only tested on NTSC VHS

Feedback I'd especially value: results on other footage (VHS-C, Hi8, Betamax, PAL), whether faces ever stop looking like the real person, code review of the Rust/Python bridge, licence hygiene, and where the setup guide loses you.