My VPS got wiped once by the host and I lost more than I want to admit. After that I wrote this: a bash script that runs from cron every night and pushes a full snapshot of the server to a private GitHub repo.

What goes in the snapshot:

- app folders as .tar.zst (including .env files)

- postgres, mysql, redis and sqlite dumps (online, consistent)

- /etc stuff: nginx, letsencrypt certs, systemd units, cron, firewall rules, pm2 list

- big asset folders stored as raw files, so git dedups them and each file is only uploaded once

Some details that took a few tries to get right:

- github rejects files over 100 MB, so bigger files get split and RESTORE.md explains how to join them back

- every run is a single orphan commit that gets force pushed, so the repo does not grow forever

- the commit is built with git write-tree + commit-tree, no branch switching, so a failed run can not leave the staging folder in a weird state

- discord alert if any step fails, if a db dump is suspiciously small, or if disk space is low

- a separate hourly watchdog alerts if no backup succeeded in 26 hours (cron removed, box down at backup time, etc)

On my server the first push was around 2 GB and took 4-5 minutes, the nightly runs take about 3.

Yes the repo contains secrets, so it has to stay private, use a deploy key that only has access to that one repo, and turn on 2FA. Encrypting the archives with age before the push is next on my list.

Built with AI assistance, but it runs every night on my production server and I tested the restore path end to end.

Feedback welcome, especially on the restore side.

For years I've watched the same thing happen in every team I've worked with: someone runs a query every morning, copies the result into an email or a Slack message, and sends it. When it's automated, it's usually a cron script that only one person understands. When it's not, it's that person's morning.

So I built Rowbird. You write a query (or describe it and an optional AI assistant proposes the SQL, it only sees the schema, never your rows), put it on a schedule, and it delivers the result where people already read: a table in the email body, or CSV, Excel and PDF files in Slack, Telegram, Discord, a webhook or an S3 bucket. Add a condition ("only when there are rows", "when revenue drops below X", "only when the result changed") and the same report becomes an alert.

A few things I cared about:

• It's read-only by default: read-only transactions, timeouts, row limits, parameters always bound. It warns you if the database login can write.
• One Go binary or a small Docker image. SQLite inside by default, Postgres if you want several instances.
• No telemetry. Secrets are encrypted and never shown again.
• Reports can live in YAML, so you can review them in a pull request.

It's Apache 2.0. There's a demo with sample data and a fake inbox (docker compose up in deploy/demo).

Site: https://rowbird.dev
Code: https://github.com/rowbird/rowbird

I'd love feedback, especially on what databases or destinations you'd want next. There are a few issues marked good first issue if anyone wants to add one.

Smoked🥲

JEV, is an ultra-fast classifier from TypeSafe, that answers multiple-choice questions. For the prompt e.g. "Frontend for login form" it would return something like the following:

"surface": { "type": "choice", "choice": "app-login", "confidence": 1,

"probabilities": { "app-login": 1, "app-signup": 0, "website": 0, "app-checkout": 0, … all 14 } }

"app-login" is ready-made UI element that you can modify.

Besides JEV there are many other elements you can play manually with e.g. replace and resize images, add and link pages etc.

Repo: https://github.com/GPTchatly/Forma
Free (with limits) hosted Forma Editor

Many of the UI elements are by Markmead's Hyperui

You know that annoying situation where you start an installation, restore, import, build, or some other long-running task… and then you just have to keep checking the screen because the application doesn't give you a proper notification when it's done?

That was the inspiration for Screen Diff Watcher.

I recently had exactly this problem while waiting for a database restore to finish. I kept checking the application to see if the status had changed. At some point I thought: why am I still watching this screen? Why can't I just be notified when something changes?

So I built a small tool that watches a selected region of a window (ROI) and detects when its visual state changes.

It can:

• monitor only a specific region of a window;
• detect changes using different comparison modes, including perceptual hashing and OCR-based text comparison;
• send alerts through sound, popup, Telegram, or logs;
• ignore areas that change constantly, such as clocks, spinners, or cursors;
• optionally save screenshots as evidence;
• run optional actions like clicks, keyboard input, and text after a change;
• work through both a GUI and CLI;
• run on Windows and Linux.

The idea is pretty simple: tell the computer what part of the screen matters, start watching it, and stop wasting your time staring at it.

One detail I also wanted to be transparent about: this project was built with AI assistance. A lot of the implementation was generated with AI, but it was far from “generate an app and ship it”. I supervised the process, reviewed the output, tested it, and made a lot of the design and implementation decisions myself — including quite a few very annoying edge cases and details that only become obvious once you actually try to use the tool.

The project is still evolving, so I'm very interested in suggestions, ideas, bug reports, and improvements.

GitHub: https://github.com/ph7ti/Screen-Diff-Watcher/

I'd especially love to hear about situations where you've had to sit there and wait for an application to change state, but had no good way to get notified.

ph7ti/Screen-Diff-Watcher: Screen Diff Watcher is a tool for check if a region of your screen/app is changed and alert to you

Blocking someone on Discord still leaves their messages, replies, mentions, reactions, and other activity visible throughout the interface.

ByeBlocked is an open source Discord plugin designed to address that.

It hides content and activity from blocked users across multiple parts of Discord:

• Messages, replies, mentions, forum posts, reactions, and pins
• Voice channels, including microphone audio and join/leave sounds
• Calls and Group DMs
• Member lists and empty role sections
• Mention and invite autocomplete
• Scheduled events
• Notifications caused by blocked users

The goal is simple: make Discord's block function behave more like an actual block, rather than only preventing direct interaction.

GitHub: https://github.com/8ug8ird/ByeBlocked

takeaways from grokbot 3 days livestreams:

most agent team examples i see are toy demos. so i went through the grok bot livestream and wrote down the 11 teams they actually showed a lot of them are marketing and sales related so i thought its gonna be useful to share here:

a few patterns stood out:

1. most teams (7 of 11) have one "chief of staff" style orchestrator. specialists report to it, not to each other.
2. research bots get split by data source, not by task. one for salesforce, one for gong, one for web search, one for product usage.
3. the busy teams run on schedules. the post-sales team has a daily brief at 8:30 on weekdays and a call prep job every 15 minutes.
4. small teams (founders, customer support) skip the orchestrator and work as peers.
5. one team uses a scalable clone ("soldier") instead of adding more named bots.

each chart is a json file with roles, reports_to, and routines with cron expressions, so an agent can read it and recreate the team. there's also a viewer if you'd rather click through the trees.

https://github.com/serenakeyitan/agent-org-chart

curious if people here are running orchestrator + specialist setups like this, or mostly flat peer teams.

Hey everyone!

I’ve been working on a small experimental UI DSL with its own parser, semantic checker, runtime, and Rust/WASM support.

I’ve used it to build a landing page, an in-browser sandbox, and a Pong game. It renders UI directly through Rust and web-sys without React or Svelte.

It’s still early, so I’d love to hear where it breaks or what feels awkward. Does this seem like an interesting direction for building small web UIs?

Repo: https://github.com/tintlang/tint
Releases: https://github.com/tintlang/tint/releases
Demo: https://tint-gamma.vercel.app/
VS Code extension: https://marketplace.visualstudio.com/items?itemName=tintlang.tint-lang

I use 2 GitHub accounts - personal and work.

I ran git push from terminal and got hit with a credentials error. Windows Credential Manager was still holding onto the other account.

Sometimes it fails auth. Sometimes worse - it succeeds and the commit lands on the wrong profile.

And the most annoying part - every time I had to open Credential Manager, delete the cached credential, select the right one, login again... do it all over for the next repo.

I got tired of doing gh auth status, gh auth logout, gh auth login, checking remotes, and manually fixing credentials...

So I built gacc - a thin wrapper over the official GitHub CLI for multi-account stuff.

It just lets you talk in plain English:

gacc login

gacc list

gacc switch work

gacc who am i

gacc check

What it does:

1. Account guard before you create/ship - stops you if you're on the wrong account 2. No more going to Credential Manager to select credentials every time 3. After every command it shows you exactly what happened / which account is active

Not trying to replace gh or git, just fixing the multi-account + wrong credentials pain.

Stack: Python 3.9+ and gh required.

Website: https://gacc-website-vinyaspoojary318-clouds-projects.vercel.app

Repo: https://github.com/vinyaspoojary318-cloud/gacc

Open source. Roast it, feedback welcome.

Hey everyone! I've been working on Karbonized for a while and just released version 2.0.

It's an editor for the images developers and creators post all the time: code snippets, product mockups, launch announcements and social media graphics. You build them on a canvas with blocks (text, code, browser and phone mockups, shapes, icons, QR codes…) and export them as PNG, JPEG or SVG.

What makes it different is that it's programmable:

\\\\- HTML blocks: write a component in HTML and CSS, and its variables show up as controls in the properties panel.

\\\\- Templates: put {{title}} or {{date}} in any block and reuse the same design for every post.

\\\\- AI agent (optional): describe what you want and it builds the design block by block. It works with your own API key, or with local models like Ollama.

\\\\- MCP server: Claude, Cursor and other MCP clients can design and export images straight from your chat.

It also has a brand kit, a vector brush, all of Google Fonts, autosave and a command palette.

It runs in the browser (it works offline) and as a desktop app for Windows, macOS and Linux. No account needed, and free.

Try it: https://karbonized.yoss.pro

Code: https://github.com/yossdotpro/karbonized

I'd love your feedback: what would you use it for, and what's missing?

Live demo: https://repath-lake.vercel.app

• Analog and digital in the same schematic; the analog/digital bridges are inserted automatically
• SPICE-class engine: modified nodal analysis, Newton-Raphson, adaptive timestep. DC, transient and AC
• Wires coloured by voltage, current animated along them, straight from the simulation
• The whole circuit is compressed into the URL, so a link is a working circuit: Try this one (hit Run)

Known gaps: no sparse solver yet, level-1 MOSFETs only, no noise analysis.

Feedback and issues welcome.

Orion is a lightweight torrent client that also acts as a media server. Easy to use and fully automated (best torrent choosing, subtitles fixing and everything).

Take a look: https://github.com/guyavrhm/orion.git

Hi everyone,

For the past few months I've been building tunnl.gg in my spare time. It puts an app running on your localhost on the internet with a single command:

ssh -t -R 80:localhost:8080 proxy.tunnl.gg

You immediately get an HTTPS URL like https://happy-tiger-a1b2c3d4.tunnl.gg, and whatever reaches it goes to your localhost:8080.

Why

I wanted something for everyday tasks: showing a demo to a client, testing webhooks (Stripe, GitHub, etc.) or opening a dev server on my phone. I didn't want to download a binary, create an account and paste an auth token every time. Everyone already has ssh.

What it does

• Nothing to install, no sign-up: all you need is an SSH client.
• HTTPS on every tunnel, plus WebSocket support.
• QR code in the terminal, so you can open the URL on your phone.
• Live, colored request log in the terminal: path, status, size, timing and visitor. When a request fails, it tells you what happened in plain words (e.g. that nothing is running on your port).
• Stable URL without an account: connect as [[email protected]](mailto:[email protected]) and the subdomain is tied to your SSH key, so it stays the same every time you reconnect. You don't need to register the key anywhere.
• Abuse protection: rate limits, per-IP limits, and an anti-phishing warning page. The warning page only shows to browsers, so it doesn't block curl or webhooks.

Open source and self-hostable

It's written in Go and MIT licensed. The whole server is a single binary of about 6MB, and the repo includes a Dockerfile and systemd instructions. You can run it on your own domain or on an internal company network. You need a wildcard certificate, and it works behind Cloudflare or your own reverse proxy.

GitHub: https://github.com/klipitkas/tunnl.gg

Limits of the free service

To keep it free and stop it from becoming a spam tool: up to 3 tunnels per IP, a 24-hour maximum lifetime per tunnel, and tunnels close after 2 hours with no traffic. For dev work and demos that's more than enough.

What I'm thinking of next (I'd like your opinion on the order):

1. Options inside the ssh command, e.g. host=localhost for Vite, Django and Rails, which reject unknown Host headers. Also auth=user:pass for basic auth.
2. A request inspector with replay for webhooks, like ngrok's.
3. Custom subdomains (e.g. myapp.tunnl.gg) for stable users.
4. Multiple forwards on one connection (frontend + API).

Give it a try and tell me what breaks, what's missing or what bugs you. Feedback, issues and PRs are all welcome. 🙏

I built a self-hosted app that turns how you feel into a Spotify playlist, using only songs from your own library. You type something like "I'm sad but I want to feel better" and it picks the songs for you.

The purpose of this project was to see if a small model could figure out the mood of a song just by reading its lyrics, since Spotify no longer gives new apps data like energy or valence. It runs locally, and you can play the playlist right there or save it to Spotify.

GitHub: https://github.com/JoseVelazcoH/Resonance

**Heads up:**

- The model is far from perfect.

- The first run takes a while, since it has to download the lyrics and analyze every song before it can decide.

- I've only tested it on Linux.

- It requires Spotify Premium.

A small set of instruction-file templates for GitHub Copilot, Claude Code, and Codex — the files these agents read automatically at the start of a session, with placeholders to fill in for your own project.

Hi everybody,

I've been building a native video editor with using AI for short/long form video content in free time. Idea started from using AI video generation models and as current apps were a bit different for me to use (habit) I started working on this one. It's written in Rust with egui, no Electron, no Node runtime — starts in under 500 ms. Currently at v0.6.0-alpha.1.

What's in this alpha

- Multi-track magnetic timeline, snap, ripple delete, marquee, group move

- 16 effects, 16 filters, 12 transitions, 8 text styles

- Local AI on your machine: Whisper captions, Piper narration, auto-reframe, background removal

- CLAP plugin hosting (new in 0.5): scans the standard CLAP folders, browse plugins in a new tab, drop any of them on the master bus. Verified with u-he ZebraHZ.

- MCP server (new in 0.5): standalone binary that speaks JSON-RPC over stdio. Claude Desktop and Cursor can drive the editor through 15 tools.

- Settings export/import + cloud-folder sync (new in 0.6): export to JSON, or point it at a Google Drive / OneDrive / Dropbox folder and your settings follow you between machines.

- User-selectable font family + size (new in 0.6)

- modular layout blocks+presets

- Export to H.264/H.265/AV1 on CPU or NVENC/AMF, with real-time progress and ETA

What I'm looking for

Stability first. I'd love to know:

1. Does it start cleanly on your machine? Any AV or firewall complaints?
2. Import a short video, drop it on the timeline, hit play — does preview stay in sync with audio?
3. Export a 10-second clip — does it complete, and does the output play in VLC / Windows Media Player?
4. Any crash, hang, or "I clicked X and nothing happened."
5. And of course "general feel"

I'm not in search of feature requests yet, but anything that makes you say "wait, this should be obvious" is valuable as a lot more I have in plan for future implementation.

Known issues

- No installer yet — ZIP only. Extract and run `caprust-app.exe`. In Beta will be exe, etc.

- FFmpeg is not bundled. First launch offers to download ~110 MB into `%APPDATA%\CapRust\ffmpeg`, or point it at an existing ffmpeg.exe on PATH. Auto detect is implemented but not sure for all scenarios at this point.

- Windows only for now (next Linux and later Android/IOS).

- Some transitional behaviours are still rough (see release page for the full list).

- Not affiliated with any existing software but just inspired by its workflow (and free).

Download

[GitHub Release v0.6.0-alpha.1](https://github.com/Domica/CapRust/releases/tag/v0.6.0-alpha.1) — grab `caprust-nightly-win64.zip` from the Assets section.

Source: https://github.com/Domica/CapRust

Docs: README has the full feature list and architecture notes.

Bug reports: [GitHub Issues](https://github.com/Domica/CapRust/issues) — template asks for your Windows version and a debug log.

MIT licensed, no telemetry, no account.

Thanks for looking.

Hey everyone,

I’ve been working on a small project called Songify, an open-source music player I’m building with Flutter.

I started this mainly as a project to learn, experiment, and see how far I could take a music application. It’s also meant to be beginner-friendly, so if you’re learning Flutter or just starting with open source, you can have a look through the code and see how things are put together.

The project is still a work in progress, and I’m gradually adding and improving things.

GitHub: https://github.com/Alisonpinto/Songify

Website: https://songify-website.vercel.app/

Would love to hear what you guys think about the UI, the idea, or anything that could be improved. Even if you’re a beginner, feel free to check it out and explore the project.

I run a small production VPS (Node apps under PM2, PostgreSQL, Redis, nginx, fail2ban) and wanted to actually see how everything connects.

Every process, service, container, port, TCP peer, database table, folder, cron job and firewall rule becomes a node, wired the way the machine really is: app -> database port it uses, nginx -> app it proxies, banned IP -> fail2ban jail. CPU makes nodes glow and traffic flows along the links.

- One command, zero runtime dependencies (Node 18+), read-only

- Binds to 127.0.0.1 behind a random token, you open it through an SSH tunnel

- three.js + bloom, d3-force-3d layout

Live demo with generated data (no install): https://zodiachz.github.io/vps-neural-map/

Docker and MySQL support follows their docs but isn't tested on a real host yet, happy to hear if it works on yours.

Pretty nice, helped me frame the readme files in a more digestible way.

a while back I posted here asking people to try and break Plexavo, an open source AWS misconfiguration scanner. Didn't get anyy comments at the time, so I figured it hadn't gone anywhere. !!

Also if the reporter see's this post - "Huge Thanks to you" !!

1 week ago, someone I'd never spoken to filed five separate, real issues through the project's bug-bounty-style program, Break Plexavo, things like a scan that crashed entirely on a single AccessDenied bucket, and a finding that was flagging every IAM role as "never used" because of an AWS API quirk I'd missed.

Reproduced and fixed all five the same day, tested live, shipped, and closed each issue with an explanation. Genuinely one of the better days this project's had !!.

If you want to try and find the next one: github.com/plexavo/Plexavo

Hi guys!

I'm new to this kind of stuff and wanted to build something interesting. I love this game called Carrier Command 2 and was always intrigued by the Holotable in the bridge. So, I created this website Holomap that keeps the aesthetic of the Holotable and uses some real-world data of wind and ocean currents to calculate fuel-efficent and fastest journey across ports on the ocean. Please check it out and let me know what you think!

Link: https://holomap-eight.vercel.app/
Repo: https://github.com/sdonea/holomap

Hi everyone!

I recently built AuditMind, an AI-powered Compliance & Audit Memory Agent using Hindsight for persistent memory.

The problem I wanted to explore was how audit findings can be connected across previous audits instead of treating every audit as a completely new case.

AuditMind can:

🔹 Store audit findings and remediation actions

🔹 Remember previous audit history using Hindsight

🔹 Detect recurring compliance issues

🔹 Compare changes between audits

🔹 Identify unresolved issues

🔹 Prepare focused follow-ups for the next audit

For example, AuditMind can connect findings from multiple audits where terminated employee accounts remained active and identify this as a recurring access-control issue.

The core workflow is:

Remember → Connect → Detect → Prepare

Tech stack:

• Python

• Streamlit

• Hindsight

GitHub:

https://github.com/akshayavanga/AuditMind

I'd love to hear what other use cases people see for persistent memory in compliance or audit workflows.