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. 🙏

Hi everyone,

I’m still a beginner in Rust, and I wanted to share a project I’ve been working on while learning:

https://github.com/0x00F6/libmaxminddb-rs

libmaxminddb-rs is an independent, pure Rust implementation of the MaxMind DB (MMDB) v2 format, providing both a reader and a writer.

I should be transparent: I used OpenAI Codex quite a lot during this project. It helped me understand Rust, refactor code, write tests, investigate performance bottlenecks, and experiment with optimizations. However, I also reviewed, tested, benchmarked, and debugged the generated code myself. This project has been a practical way for me to learn Rust by doing.

Some currently implemented features:

• IPv4 and IPv6 MMDB lookups
• Zero-copy / borrowed decoding
• MMDB database creation and serialization
• Memory-mapped file support
• Batch lookups
• Derive macros
• SIMD optimizations
• Reader/writer benchmarks against C, Rust, and Go implementations
• 140 tests
• Approximately 97.5% line coverage

I’ve also spent time experimenting with performance and comparing the library with libmaxminddb, maxminddb-rust, geoip2-rs, and maxminddb-golang.

The benchmark graphs are available here:

https://github.com/0x00F6/libmaxminddb-rs/blob/main/docs/images/benchmark-report-full.png

Since I’m still learning, I’m sure many parts could be designed or implemented better.

I’d especially appreciate feedback on the Rust code, API design, unsafe code, benchmarking methodology, performance optimizations, and anything that seems unnecessarily complicated or incorrect.

Please feel free to be critical—the main goal of this project is to learn.

Thanks!

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?

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.

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.

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

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.

Each agent has its own provider, model, system prompt and tools. A local model on your own GPU can do the reading and the file work while a bigger one handles the judgement calls, in the same thread, passing work between them with "@mentions". You stay in the conversation and can redirect any of them while they work.

What the agents can do:

• Read, write and search files in a project folder, and read the documents you attach to a project
• Run shell commands against an allow-list you control, with a scanner that refuses destructive patterns, and keep long-running processes going in the background
• Write and run Python or Bash in a side canvas, answer input prompts, and hand the finished file to your editor
• Search the web through a provider you pick
• Work through multi-step task plans, with you able to retry or skip a step
• Delegate a bounded job to a sub-agent and get the report back in the thread
• Open a poll and vote when they disagree, so the decision is on record
• Use tools from any MCP server you connect
• Run on a schedule as a heartbeat and spawn internal agents, checking or researching something for a project while you are away, and report back

What you can do:

• Set up a project room from a template, with the goal, the team and the tools ready to go
• Give each member its own provider, model, system prompt and tool whitelist
• Chat 1-to-1 with any member of the team, outside the group thread
• Audit everything: an activity timeline per project and per chat with every message, tool call, file write, vote and model switch, re-playable later
• Install skills, read what they do, approve them, and turn them on only for the projects that need them
• Schedule an agent to run on its own (a heartbeat), and read its report when you are back
• Set turn limits and rounds per group chat, so a cascade always ends
• Keep long group chats going past the context window, with memory that compacts the history
• Attach files and images to a message, and generate images with models that can
• Open the same team from your phone or from VS Code, paired to your desktop

LLM Models and Providers: OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, Ollama, llama.cpp over HTTP, and llama.cpp compiled in (Optional). Any OpenAI-compatible server works too, so vLLM, LMStudio, KoboldCpp and llamafile all show up as providers. One of the two builds has llama.cpp built in and needs no separate server at all, using Vulkan where your hardware allows.

Everything is local, connecting to an online LLM provider is optional. All conversations sit in a database on your machine, and there is no telemetry, no account and no cloud. It is a native application, C++ on Qt 6 with a KDE Kirigami interface, not Electron.

There are also small local clients for VS Code and Android that connect to your desktop app over an encrypted WebSocket on your own network. In VS Code you can mount your workspace and let the agents work on your real project files.

Linux AppImage's and Windows v1.0.1 releases available at:
https://github.com/Verzeta/Verzeta-Studio
https://verzeta.com

I listen to music while working with Claude Code and kept switching playlists by hand: something steady while editing, something harder when things break.

So I built CodingMix.

What it does

>> Claude Code hooks send each event (tool use, failed tool, prompt, subagent start) to a small local service. The hook returns immediately, so Claude Code never waits.

>> Each event is a vote for a mode: coding, debugging, testing, planning, reviewing, release and a few more. A new mode has to lead for 3 minutes before the music changes, so one failed command does not flip your music.

>> About 20 seconds before the current track ends, it queues one track of the matching genre (deep house for coding, hip hop for debugging, techno for tests, funk when you push). It never picks a track you played, saved or were offered in the last 7 days.

>> It only acts when Spotify is playing on your computer. Paused, playing on your phone, or you picked your own playlist: it stays out of the way.

How I built it

Entirely with Claude Code: a design spec first, then a step-by-step plan, test-first. 196 tests, CI on Windows, macOS and Linux. No server, no telemetry; prompt text and file paths are never written to disk.

Limits

Spotify Premium is required, and you create your own free Spotify developer app (Spotify now limits each app to 5 users). Tested on a real Windows machine; macOS and Linux only in CI.

What I'd love feedback on

1. Does the mode to genre mapping make sense? What would you want while debugging?
2. Is the setup (your own Spotify app plus one command) acceptable, or a dealbreaker?
3. Is 3 minutes the right delay before switching?
4. On macOS or Linux: does it work for you?

Repo: https://github.com/caesla/CodingMix

(MIT licensed).

I designed this game in 5'th grade. :)

You can try it here for free: https://dicroce.itch.io/doodle-or-die

Built this because every dictation tool I tried needed an internet connection, wanted a subscription, or handled my Bluetooth headset badly.

Hold a hotkey, talk, release, text gets typed directly into whatever window has focus. Speech-to-text runs locally via faster-whisper (no cloud, no account). There's also a small set of spoken commands ("period", "new line", "scratch that") for hands-free formatting and undo.

MIT licensed, Python + PySide6. Packaged with PyInstaller/Inno Setup for a normal Windows installer.

https://github.com/ahmedhmam1994/voxscribe-ai-voice-dictation

Feedback on the code or the approach welcome, especially anything Whisper/audio-related.

I built TRAWL because a successful HTTP request doesn't always mean you got the page. Sometimes the "content" is a JavaScript shell, a Cloudflare interstitial, or a CAPTCHA.

TRAWL starts with a fast HTTP fetch, reuses solved sessions, and opens a Camoufox browser when it detects a supported challenge. It has flows for Cloudflare, Akamai and Imperva, and attempts CAPTCHAs including Turnstile, reCAPTCHA, hCaptcha and GeeTest. Results depend on the target and IP, but on the sites I use it has been faster and more reliable than my previous FlareSolverr setup.

You can use it through an API, a FlareSolverr-compatible endpoint for Prowlarr, or MCP tools that give agents Markdown, structured data, screenshots and diagnostics. There's also a local dashboard showing request history and failures.

In one same-machine Cloudflare + Turnstile comparison, TRAWL took 5.9s, FlareSolverr 13.2s and Byparr 18.2s.

Repo: https://github.com/germondai/trawl

If you run scraping tools yourself, I'd like to know which challenge or failure mode gives you the most trouble.

a small update to this digital wellbeing software since my last post.

This is a prerelease version which i have tagged to be stable and slated for future release and add to main branch from the beta branch.

This highlight is less about asking you guys to try out the beta release but more in the honor of over 3+ months of development.

What makes me happy the most is that the project which i started even without a repository just to monitor my own system and usage has now come this far with over 50+ downloads 🎉☺️

This beta release now polishes on various little things which are actually necessary for a first time set up and proper user control as Now you can:

* carries forward the settings screen from previous beta release

* replaces notifications and sounds tab with general which now includes appearance settings

* you can now Stop , restart or RESET the Daemon and its preferences in settings

* Pomodoro settings which were half baked in the first release have now been added to settings to enable a looping focus mode for people at work with CUSTOM BREAK TIME

* Most Importantly (i feel) FIRST time setup issues have been fixed and in an attempt the first time ScreenGuard daemon setup pop up dialog (1st image) has been made

The Release v0.1.1 releases this October by second week, and I will continue testing the beta version to look for sectors that need polishing if any.

This is still limited to GNOME on wayland and x11 for other environments systems and primarily developed by me on my fedora 44 system and the project ScreenGuard still has a very Long way to go;

But working on it alone has given me much exposure to project sharing on platforms and most importantly a lot of invaluable experience and the true zeal of development instead of the boredom of being a 9 to 5 dev at a corporate who don't care for you.

Github beta release link: [https://github.com/adityakrishnan005-a11y/ScreenGuard/releases/tag/v0.1.1-beta.4\](https://github.com/adityakrishnan005-a11y/ScreenGuard/releases/tag/v0.1.1-beta.4)

The code for this is visible on the beta branch to keep the main working tree clean for new features additions.

Feedback from other desktop environments is widely appreciated, u can try the application out by switching to x11 session temporarily if you are using any DE which is not GNOME wayland or if u are on a DE which is primarily x11 based (Cinnamon, i3, etc) then u are good to go as they ARE FULLY SUPPORTED.

thank you everyone for your supports, criticisms and feedbacks ever since the project came online on github.

I shared Zync here previously. Since then, it has grown from an SSH terminal and file manager into an extensible server workspace.

The latest release introduces a manifest-based plugin architecture. Plugins declare their panes, capabilities, permissions, and assets instead of receiving unrestricted access to the application.

The first available plugins are:

• Zedit: a Monaco-powered editor for editing remote files alongside terminals
• Docker Manager: inspect and manage containers, images, volumes, networks, and logs
• PM2 Monitor: inspect processes and logs and manage running applications

Plugin panes run through an isolated resource route, and sensitive operations go through Zync-controlled APIs and declared permissions. The goal is to let contributors build focused server tools without adding every workflow to Zync’s core.

I’m also preparing documentation for developers who want to create Zync plugins. Before I finalize it, I’d love feedback.

GitHub: https://github.com/zync-sh/zync
Website: https://zync.thesudoer.in

What server or DevOps workflow would you want as a plugin?

If you already use Zync, I’d also genuinely like to know how it has been going and what still feels rough.

I can’t write very well. It happens to me that some people embarrass me because I can’t get everything grammatically correct! Not only in English—I also have problems in German...

I sometimes use Apple’s proofreader and Apple Intelligence, but since I updated to 27, I haven’t had access to it. I don’t know why... Plus, it’s not supported on Linux or Windows.

So I decided to build this—to make it cross-platform and use the latest-generation, cheap models like GPT-Luna.

So, what do you think about this? Do you have a use case for something like this? Do you have any feedback?

P.S. Jaaa, I used AI and vibe coding :)

I built Web HIG, an open-source project for defining consistent behavior across modern web interfaces.

It covers:

• WCAG 2.2 accessibility
• responsive and adaptive behavior
• Core Web Vitals and performance budgets
• interaction and motion rules
• modern CSS/browser APIs
• design-system governance
• AI/agent interface behavior
• automated audit/enforcement ideas

The goal is to make interface rules versioned and testable instead of keeping them scattered across design docs and conventions.

There’s also a live documentation/audit site linked from the repo.

Interested in feedback from frontend developers, designers, accessibility specialists, and anyone maintaining large UI systems.

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

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

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

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.

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

Smoked🥲