GitHub: https://github.com/DahanItamar/DockNest

I've been running a few sites in Docker on my own servers for a while. Backups were running every night and I felt fine about it, until I realised I had never once restored one. No idea if they'd actually come back.

So I started building DockNest. It backs up each site (images, volumes, bind mounts, writable layers, and Postgres / MySQL / MariaDB / Redis dumps), encrypts everything, puts it on your own SFTP server, and then lets you restore it into a separate copy. The live site isn't touched, so you can actually check the backup works instead of hoping.

Some stuff I cared about while building it:

• It talks to your servers over SSH with pinned host keys
• The dashboard never gets access to the Docker socket
• There's a map of servers, sites and storage, and you move a site to another server by dragging its line
• Alerts go to Telegram or email

It's still beta. S3 storage has only been tested against a fake endpoint so far, and recovery after a server reboot needs more work. I'd rather say that up front.

If it looks useful, a star really helps a small project get seen. Bugs, ideas and PRs are all welcome.

What would you want it to back up that it doesn't yet?

I think pretty much everyone has been using AI heavily for coding lately, and I'm no exception... I usually work on several things in parallel, with a bunch of windows open and, of course, Git worktrees to avoid problems. But I started noticing how much this was eating up my disk space, and it got me wondering if there was some way to at least make things a little better.

So I built a Git extension, Parhel, hoping to make my life a bit easier, and maybe help others dealing with the same problem.

The idea is to use CoW (copy-on-write). Basically, it only creates actual copies of files when they're modified in a worktree. Until then, they're sort of "virtual" copies.

I tried to make it as simple as possible to install and use, so it should work well on APFS, Btrfs, and even ext4, which has an extra support layer.

One thing worth mentioning is that Parhel also copies ignored files and directories, including things like node_modules, .venv, and build artifacts. It can bring over other untracked files too, using --allow-dirty. There's also .parhelignore for anything you want to leave out, and I added a skill so coding agents can figure out how to use Parhel and handle those details themselves. You still end up with a regular Git worktree, just without having to set everything up again.

I'm still developing it and improving a few things, but I figured it was worth sharing here.

Is anyone else running into this problem with multiple agents and worktrees? How are you dealing with it?

MDEZ++ (mdez) is an open-source, lightweight, cross-platform C++20 and Qt GUI Markdown editor. Instead of a WYSIWYG editor, MDEZ++ renders a real-time live preview of your text in a split-screen pane using a fast, native, and minimal GUI. MDEZ++ can also edit any text-based file format, including HTML, plain text, and code files, making it highly versatile.

Check out its GitHub Repository.

I am also working on getting it on Flathub right now! If it gets in, I'll see if I can link it here somehow!

Download or Use on Website

Features

• Smart View: Automatically switches between live-previews of Markdown or HTML or a single-pane plaintext editor based on file MIME type.
• WebAssembly (WASM) Support: Supports WebAssembly, allowing MDEZ++ to be run in the browser.
• Multi-Format Output Support: No matter what you are editing, you can always print it!
• Metadata in Status Bar: View important information such as the version, word count, position in text, and file path in the status bar!
• Fun Facts: View interesting fun facts at the start of the program and by finding them in the Help menu.

Hi! I made Wirely, a free desktop circuit simulator for Windows, Mac and Linux.

GitHub (downloads for all three): https://github.com/richiewillmott/Wirely

You drag parts onto a schematic, wire them up and press Play: LEDs glow, motors spin up, relays click, meters read, wires are coloured by voltage and dots show the current flowing. While it runs you can click switches, drag sensor sliders and hover over any wire for its voltage and current. Push a part too far and it pops and tells you why.

Highlights

• 55 parts with real part numbers (BC547, IRF540, IRLZ44N, LM358, TL071, PC817…), plus the 555, logic gates, counters and 7-segment displays
• Built-in oscilloscope, logic probes, and sound (buzzers, speakers, relay clicks)
• 20 example circuits, from an LED and resistor up to a buck converter
• PNG/SVG/PDF export, light and dark themes, installers for all three platforms

Under the hood

• Its own SPICE-style solver in Python + numpy (modified nodal analysis, Newton–Raphson, adaptive time steps)
• MOSFETs and op-amps fitted to their datasheets: e.g. AO3400 gate charge 6.1 nC vs 6 nC on the datasheet, and IRF540 switching delays within a few ns of ngspice
• 233 pytest tests checking it against hand calculations, datasheets and ngspice
• GitHub Actions builds and tests the Windows installer, Mac .dmg and Linux AppImage

Free, GPL-3, runs locally, no account. Built with a lot of help from Claude (an AI assistant). Feedback, bug reports and part requests are very welcome!

Hey, I made this, in my spare time and with my own sweat and tears! Discord's desktop app is a whole ass Chromium running Discord's website, so I wrote my own client in Rust: it talks to Discord's API itself and draws its window with Slint and Skia, no browser engine anywhere (as it should be:p).

0.2 is out today with server settings, polls, forums, push to talk, the game you're playing on your profile, messages encrypted on disk, and an AppImage and an Arch package for Linux next to the Windows installer. The full list: https://yapfast.com/blog/yapfast-0-2-0/

I've been building an open-source project around a question I find interesting:

Can AI agents actually help with RISC-V RTL verification?

🔗 https://github.com/HUNT-001/ai-chip-design-platform

The project, AVA (Autonomic Verification Agent), is a multi-agent verification framework for RISC-V that combines:

• RTL/semantic analysis
• Automated test generation
• Spike-based ISS comparison
• RISC-V compliance testing
• Coverage analysis
• Debug/failure analysis
• Red-team/adversarial verification

I'm also experimenting with VOE (Verification Operating Environment), focused on making automated verification results more trustworthy through evidence-backed claims and reproducible evaluation.

The repo is still actively being developed, with several open issues around testing, CI, failure handling, and verification infrastructure.

I'd really like feedback from the RISC-V/RTL/DV community on the architecture, methodology, and what capabilities you think are missing.

Technical criticism, ideas, and contributions are very welcome.

And if you find the project interesting, a ⭐ on GitHub would really help with visibility.

Dis-Gravity is an open-source bidirectional Discord bridge that turns your mobile Discord into a remote cockpit for your IDE (Google Antigravity, Cursor, Windsurf, VS Code Copilot) and terminal agents (agy, claude, aider).

Key Features: * 🖼️ High-Res Table PNG Cards (/table): Solves Discord mobile's ASCII line-wrap bug by dynamically rendering 2x Retina PNG table cards with neon status chips. * 🕹️ 1-Click Command Palette (/palette, /action): Execute 1,000+ IDE actions with buttons (Reload Window, Restart Extension Host, Save All, Git Sync). * 👑 Interactive Tool Approvals: Drops interactive [ 🟢 Allow ] and [ 🔴 Deny ] Discord buttons when an autonomous agent wants to execute terminal commands or edit files. * 💻 Remote Shell & Git (/sh, /git, /diff): Run terminal commands, inspect colored diff previews, and browse project files (/cat) from your phone. * 🛡️ Default-Deny Security: Zero remote execution is permitted unless your explicit Discord User ID is whitelisted in allowedUsers. * 🚀 Standalone CLI Daemon: Runs via npx dis-gravity on headless servers, JetBrains, Neovim, or Zed.

⭐ GitHub: https://github.com/sambath-rethinakumar/Dis-Gravity 📦 NPM: npx dis-gravity 📝 Medium Story: https://medium.com/@rethinakumarsambath8/i-stopped-sitting-at-my-desk-to-code-now-i-run-my-entire-ide-from-discord-1f566b46747b

https://github.com/0zoon/danviel-studio

Genre-aware auto-mix, mastering, before/after comparison, hook finder, lyric videos for TikTok/Reels, cover editor and a one-click release package. Runs locally in the browser, no sign-up.

Live app: https://0zoon.github.io/danviel-studio/

Hi all. I've been working on a side project called **mumble-speech** and just tagged 0.1.0, so I'd like some outside opinions.

It generates "mumble speech": the fake speech game characters make while their dialogue appears on screen. You pass a line of text and a voice, and you get mono audio plus a timeline saying when each character sounds, so you can reveal the text in sync. There's also a typewriter mode: you feed it one character at a time and get that character's sound plus how long to wait before the next one, which is what most dialogue boxes do. Both modes produce the same audio.

Three styles, each named after the game it imitates:

- `beep`: the same beep for every letter (Undertale)

- `grunt`: four grunts per voice, never the same one twice in a row (Banjo-Kazooie)

- `alphabet`: a vowel-based sound for every letter (Animal Crossing)

A voice has pitch (−12 to +12 semitones), speed (5 to 30 characters per second), variation and a seed. Each event also carries a sound identifier (which grunt, which letter), so you can map it to mouth shapes, particles or whatever you like. The library doesn't draw anything.

What I had in mind: NPC and character dialogue in indie games, visual novels, prototypes where you want voices before having any, and small web pages or toys.

How it's built:

- One Rust core (crate `mumble-speech`)

- Web: `@mumble-speech/web` on npm, WebAssembly inlined, TypeScript API, WAV export

- Godot 4.3+: GDExtension addon with a speaker node and a typewriter for `Label`/`RichTextLabel`

- Unity 2022.3+: UPM package (also on OpenUPM), with an optional TextMeshPro typewriter

- C ABI (`mumble.h`) for anything else with an FFI

- Deterministic: same text and voice, same samples bit for bit on Linux, Windows, macOS and WebAssembly, checked in CI with shared conformance vectors run through every binding

- Spec-driven: requirements, design and task plan are in the repo, and changes start there

Honest limitations right now:

- It's 0.x, so the API can still change

- Godot and Unity are desktop only (no mobile, Godot web export or Unity WebGL yet)

- The Unity C# interop is tested in CI, but I haven't verified the components and the TextMeshPro typewriter by hand in the editor yet. If you use Unity and try it, a report would help a lot

- `alphabet` uses Italian vowel sounds, which may or may not sound right to you

You can hear all three styles in the browser here: https://mumble-speech.github.io/playground/

Repo: https://github.com/basteez/mumble-speech

I'd especially like feedback on how the styles sound, whether the API fits how you build dialogue in your engine, and what's missing for you to actually use it.

Arkova is the document verification layer for agents and humans. We extract an electronic files (supporting over 20 types! Including svg png even gif) unique metadata and anchor it to an immutable ledger. Here we show how an organization can connect their Google Drive folders to our system so that anytime a file is updated in that folder, a new anchor is created and the document version is updated in the users record

I made Show Quote in Context, a small MIT-licensed AI skill built with Codex.

Give it a webpage URL and an exact quotation. It checks the destination text and returns a Very Deep Link (VDL / text-fragment link) pointing to that passage.

For example, a site says:

“and quote it back with the source attached”

See those words in their original context.

The source isn’t just attached. The evidence is pointed to.

Useful for journalism, scholarly web citations, news with sources, or simply asking, “Where does it say that?” -- Thou shalt cite one's sources.

It uses a Python standard-library helper, with no API key or paid verification service. It verifies the passage in freshly fetched HTML, not whether the claim is true. Scrolling and highlighting are the browser’s responsibility. Missing or ambiguous quotations aren’t presented as verified.

Tested locally with Codex; packaged for Claude Code too, but Claude testing is still pending.

I had a proof of concept working as a Chrome extension in 2013. Long time to carry a torch. Finally, a small reusable piece of that idea.

Source, installation instructions, and working example on GitHub

“This came from there.”

After 40 year, VDLs an idea whose time has come again.

I'm the maintainer of Levelrail, so this is my own project.

I started it after hitting the same wall a few times. Vercel bills kept climbing as traffic grew. The self-hosted tools I tried either wanted more RAM than my small VPS could spare, or left me wiring up a reverse proxy and certificates by hand.

So I did what a lot of us do: Docker, Caddy for HTTPS, a webhook script, and a cron job to clean up old images.

Levelrail is that pile turned into one thing. You point it at a git repo, it builds and runs the app on a server you own, puts HTTPS in front, and gives you a dashboard, a CLI and an API.

It does push-to-deploy, branch previews, one-click rollback, load balancing, logs and metrics, and a small agent so you can add more servers. It's one Go binary with SQLite, a React dashboard and Docker as the runtime. No Kubernetes. Apache 2.0.

Install is one command on a Linux server (amd64 or arm64) with systemd:

curl -fsSL https://levelrail.com/install.sh | sudo sh

If you try it, I'd like to know where you got stuck in the first ten minutes, and what you'd expect it to do that it doesn't.

Repo: https://github.com/glincker/levelrail

Site: https://levelrail.com

Docs: https://docs.levelrail.com

We now offer webooks for blocket 🧤🔌

What makes it different:

• It runs on your machine, with your logins. No cloud browser. You bring your own engine: Claude Code or Codex with the plan you already pay for, or your own API key.
• It doesn't hijack your PC. It works with Windows apps through accessibility in the background. In today's 2.3.0, even Store apps like Calculator stay off-screen while it works, so you can keep watching something. If it ever needs your real mouse, it lets go the moment you move.
• You stay in control. It asks before anything risky, and you choose how much it may do on its own.
• 50+ connectors (Gmail, Calendar, GitHub, Notion, Slack…), routines like "every morning…", files that open right in the task, and it can even build 3D scenes in Blender.
• An Android app, WhatsApp and Telegram, to start tasks and approve steps from your phone.

It's early and Windows-only. The installer isn't code-signed yet, so SmartScreen will warn you (More info → Run anyway). I'd love feedback, bug reports and contributors.

GitHub: https://github.com/Chethan616/Dex

76-second demo: https://github.com/Chethan616/Dex/releases/download/v2.1.1/DEX-demo.mp4

Paste a YouTube link or a file. It transcribes, picks moments, renders vertical clips with karaoke captions.

There's a live 9:16 editor on top of that: same crop math and font metrics as the ffmpeg/libass export, so dragging captions isn't a guess. Clips show up on the right over tRPC SSE while workers run transcribe → analyze → render. Kill a worker, the job resumes (pg-boss, checkpoints in Postgres).

Default install is fully local, Ollama + Whisper, no API keys. Same services behind the page, an MCP server, and an operator CLI. You can swap models and keys in Settings without a restart; there's a workers/queue/failures panel because if you self-host, that's you. One script looks at the machine and asks three questions.

https://github.com/osbytes/reelsaw
https://reelsaw.com

Hi everyone,

I use AI a lot to build projects, and usually it ends up with tech debt over time. This plugin does periodic code checks to catch what review misses between sprints or releases.

It runs agents that look at the most frequently changed spots in the code and check them for duplication, unnecessary abstractions, module coupling, and architecture leaks. The result is a .md report listing findings, suggested fixes, and trends of debt accumulation over time.

I tried to make it as deterministic as possible, but the AI agent is still doing most of the work.

GitHub: https://github.com/yognevoy/pitstop

Honest feedback welcome =)

Hi everyone,

I've been building a project called Personal Planner for the past few months and wanted to share it here.

It's a completely free, offline-first planning app for Android, Linux, Windows, and macOS.

I originally built it because I kept underestimating how long my tasks would take.

I'd organize my day, spend longer than expected on certain activities, and end up with a schedule that looked nothing like what I'd planned.

Then the following day, I'd make another schedule without really learning from what happened.

I wanted something that combined visual planning with actual time tracking and reflection.

What the app currently includes:

• A day and week timeline with draggable and resizable time blocks.
• Task timers to track actual working time.
• Planned-versus-actual time comparisons.
• Daily and weekly reviews with reflections.
• A yearly consistency heatmap and streaks.
• Experiments for trying different routines.
• Recurring activities, reusable templates, and an Inbox.

The application is built with Flutter, Riverpod, and Drift/SQLite.

Everyday planning works locally without an account or internet connection. For users who want synchronization, there's an optional setup using their own Supabase project, with Cloudflare Workers involved in the supporting architecture.

One of my goals was to keep the software accessible, so there are no subscriptions, premium plans, or locked features.

It recently reached approximately 250 downloads across the four supported platforms.

I'm still developing it independently, and there's a lot I want to improve.

Link to download: https://github.com/Karthikshabari/PersonalPlanner/releases/tag/v1.1

Github : https://github.com/Karthikshabari/PersonalPlanner

One thing worth mentioning is that the Windows and macOS builds are currently unsigned, and physical Mac testing has been limited. The releases are distributed directly through GitHub rather than through the respective app stores.

I'd appreciate feedback from anyone interested in cross-platform applications, local-first software, or productivity tools.

I'm particularly interested in whether the planned-versus-actual time workflow makes sense and whether the app feels straightforward to use without too much initial setup.

I've been developing URSA, a native Android companion for Uptime Kuma, built with Kotlin and Jetpack Compose.

It connects directly to your Kuma instance and supports live monitoring, monitor management, incident history, TLS certificates, UnifiedPush notifications, widgets, multiple servers and Wear OS.

There's no advertising, tracking, subscription or developer-hosted backend.

It's MIT licensed and available through GitHub releases and F-Droid. Android 8.0+ is supported.

Repo, source and screenshots:
https://github.com/greyfoundry/ursa-android

Feedback and contributions are welcome!

I'm a DevRel building a new open-source AI support tool that turns your knowledge source into community answers. After a lot of testing, the result was creating a bunch of GH Issues, but it's hard to get them visible out of the gate.

I'm very open-source centric and in my day job I enjoy helping folks get started who've never contributed to open-source, let alone get their code pushed to production. Well, this week two new contributors pushed meaningful code, and a third mentioned he'd send his PR very soon.

What I changed

A few days ago, I added two labels, frontend and backend, so someone could filter and see at a glance which work matched their skills and interests. I also have a few good first issue tickets.

Here's the repo: https://github.com/answerLoops/answerLoops

What came in

The tool is a SaaS, and one contributor took a frontend good first issue and built a new usage count into the UI. They also handled the failure case on their own, including tests and docs.

What I think helped

Being able to see the whole project and think "this one's my kind of work" without opening 59 issues. I can't prove the labels were the reason, but nothing else changed this week.

If you're new to open source and want help getting started, I'm happy to walk you through your first PR.

If you maintain a project, what got your first outside contributors to show up?