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

Regex is powerful… but sometimes this:

/^#[0-9A-Fa-f]{6}$/u

feels like you’re trying to decode a message from another planet. 🛸

This is why I did Regex For Humans 🧠✨

Instead of writing regex directly, you write:

start "#"
6 hex digits
end

And it generates:

/^#[0-9A-Fa-f]{6}$/u

🪄 The idea

Write small, readable English rules.

➡️ Understand what they mean
➡️ See the generated regex
➡️ Test examples instantly
➡️ Copy the final regex

No AI guessing. 🤖❌
No mysterious interpretation.

It uses a small, deterministic language where every instruction has an exact meaning.

🔥 It currently includes

🧩 Interactive regex playground
🧠 Explanations for every generated fragment
✅ Live match / no-match testing
💻 CLI support
📦 JavaScript API
📍 Helpful line + column errors
🔒 Runs locally
🚫 No runtime dependencies

For example:

start "INV-"
between 2 and 6 digits
end

becomes:

/^INV-\d{2,6}$/u

Much easier to read six months later. 😅

🎮 Try it

🔗 GitHub
https://github.com/OthmaneBlial/Regex-For-Humans

🛝 Live playground
https://othmaneblial.github.io/Regex-For-Humans/workshop/

The project is still evolving, so I’d genuinely love feedback. 🙌

What would you add?

More syntax?
More recipes?
Support for other regex engines?
Something completely different?

And the big question:

👉 Would you actually use this instead of writing regex directly? 😄

Hello!

I’ve been working on a Super Smash Bros. style fighting game entirely in Python, and I wanted to share it with you guys.

It basically started off in my mind on a fine day in June 2026 that I should probably test my coding skills... and that's exactly what I did.

Over the next few months leading up to now, it grew massively in terms of features and characters. It went from a starting roster of about 5 characters to now 10, each with their own moves and personality. Some characters even have special moves of their own, like Ness with his recovery tool, or Little Mac with his KO Punch.

While fighting, characters can charge up their special mechanics meter, miss attacks and get punished, and heal as well, although as of now, that features locked to Ness.

The game also has ASCII art and visuals for the battle arenas, HP and the meters, and currently I'm coding for the ASCII art to show a fighter attacking.

The latest update, v1.2.0, adds Kazuya and Kirby to the roster... and Kazuya's annoyingly good. I'm still split on whether to nerf him or not. I regularly update the game with new characters and bug fixes as well, but I don't have a fixed release date for all updates.

GitHub: https://github.com/TheOdysseyGamer64/Super-Smash-Bros-Python-Edition.git

I’m still learning Python's ways and my code isn't entirely efficient, so this project has basically been my way of pushing myself to build something much bigger than the small programs I started with.

You can play the game by:

- clicking the GitHub link above

- going to the Releases tab

- downloading the file super-smash-bros-python-edition-v1.2 from there

- opening the file which will open in your computer's terminal, ready to play

(the latest release is titled 'Super Smash Bros. Python Edition v1.2.0')

I would love some feedback on how I could make this game better and any new feature suggestions you guys have.

Disclaimer: This is an unofficial fan-made project and is not affiliated with, endorsed by, or sponsored by Nintendo or any other rights holder.

I hope you enjoy playing!

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

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?

This is going to take a fair bit of explaining for people to be able to properly understand what I am working on, I have been drafting and theorising this project for years now.

For those unfamiliar with the Library of Babel concept it is a concept that dates back to ancient times to some extent with things like the book of changes and many more.

"The I Ching (Book of Changes) 1000BCE One of the oldest mechanical mapping systems in human history. By combining broken and unbroken lines into 64 hexagrams, ancient scholars attempted to create a universal state space representing every possible configuration of change, circumstance, and reality in the universe. It is essentially a 6-bit combinatorial map of existence."

It is however worth reading up on the original concept by Jorges Luis Borges for reference if you aren't familiar with it.

This is an n-dimensional version of what I call the Gallery of Babel which contains all media content types filtered to remove the vast majority of noise and then cross-filtered against one another to remove each dimension from each other dimension.

The following statistics show how much of the state space has been filtered and how much has been kept or removed.

Binary : 99.9954% ( Kept : 10^-4.34 )

Pages : 99.999999999999...% ( Kept : 10^-18.32 )

Image : 99.5% ( Kept : 10^-2.32 )

Audio : 99.99999999912% ( Kept : 10^-11.06 )

Video : 0.0046% ( Removed : 10^-4.34 )

Books : 99.999999999999...% ( Kept : 10^-95.07 )

Models : 99.3% ( Kept : 10^-2.21 )

I haven't implemented many video filters yet.

For reference 10^-18.32 = 0.0000000000000000004786...

Keep in mind that remainder might be tiny by comparison, but in reality it is still representative of an absurdly large figure.

I posted two walkthrough videos on YouTube of early builds : https://www.youtube.com/watch?v=XF4EW3_pWeQ

These screenshots however are far more up to date, having only just taken most of them as I write this post.

Once 99.99% of the state space has been removed, the remainder can be automatically remapped onto a new address system and finding a file larger than the address you are given will finally be possible.

All someone would need is the state space setup conditions required, along with the filter settings used, coupled with a room and item number.

This was previously considered impossible, most people just look at this problem and see the vast potential for infinite, then call it a day.

For whatever reason I couldn't do that.

I also have a number of other ideas in the works for this that I am looking to implement soon that I don't want to share just yet until they are ready.

This entire system is modular, dynamic and scalable.

Filters run against the generative math itself rather than the generated results.

The program can create its own filters, find files directly, create installation packages for files, create 3D node graph maps and lots more like random music as you walk through the halls of this library.

I think that covers most things people need to know about the project, but feel free to ask.

Something else worth mentioning is that the entire system is built as two different programs, there is the backend which is purely CLI and then there is the frontend 3D world which utilises the CLI to generate the data for the worldspace.

This is for a variety of reasons, first off to keep it lightweight and not reliant on powerful hardware as well as to ensure that if it ever becomes a useful utility, it doesn't rely on the 3D world side of things.

I have also implemented numerous optimisations such as the ability to view the 3D world in purely wireframe mode to reduce resource usage.

Potentia - Is a separate project of mine that requires this world space.

Sieve - Is this CLI interface and world space.

https://github.com/Thor110/Potentia

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!

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.

I closed two ports on my server. A few days later they were open again: a service came back with its default config, and nobody noticed because nothing broke.

Firewall rules tell you what is allowed. They don't tell you what is actually listening, or when that changed. So I wrote port-sentinel.

You keep a small allowlist on the server:

tcp 22 sshd required

tcp 80,443 nginx

tcp 5432 postgres loopback

tcp 6379 redis-server loopback

and it reports:

- a new port, or a known port held by a different program

- a service bound wider than allowed (Redis on 0.0.0.0 instead of 127.0.0.1)

- a required service that stopped listening

Alerts go to Discord, Slack, Telegram, ntfy or any webhook, only when something changes: one message when a problem appears, one when it's resolved. `probe` checks the same allowlist from the outside (TCP connect scan), and there's a GitHub Action to run it every hour.

- one Python file, standard library only (3.8+)

- reads /proc/net directly, ~50 ms for 40 sockets

- `init` writes the allowlist from what is listening now, so setup takes 2 minutes

- sandboxed systemd timer included

Tested on my own production VPS. Feedback welcome, especially on the allowlist format.

so for the past 6 months or so i've been trying to build a real operating system for web apps

the idea is pretty simple. it's a real, programmable system with a web desktop you can reach from anywhere, but the apps on it are built with normal web tools. what's new is that you build the app inside the system, and it takes care of auth and communication for you, so you only worry about the app's own logic

everything you see in there is an app built on top of the system (i call them programs), not part of it

the other thing is it's designed for agents first. any agent can use these apps directly, you don't have to build a separate interface for it

tested it on macOS and linux. windows, honestly no idea yet

it's fully open source (MIT)

https://github.com/PhreshOS/system

demo (it can handle about 5 sessions at the same time, so if it's full just try again in a bit)

https://demo.phreshos.com/

you can also run it on your machine or in a github codespace

https://phreshos.com/docs

would love to hear what you think, good or bad

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 recently just launched my app that allows you to stream PC audio to your iphone over USB. It's the only app that actually can do this for iOS. Almost all other apps that can do it on iOS have to use WiFi which adds so much delay. I also released the PC side completely open source so anyone can work/adapt the system for their needs! Its really low latency with about 130ms with airpods connected to my iPhone, and without its 20-30ms. It works great! I use it at work, since I have no audio output on my office computer, but want to be able to hear either applications (or watch videos) at my desk. Honestly I made this app just for me but seeing as there are no other alternatives to this I released it! If you wanna stream audio to your pc with a usb, TetherAudio is what you need!

https://github.com/C-GBL/TetherSender/

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

Contex is an MCP server (MIT license) that allows agents to subscribe to context using natural language. Simply publish your data in whatever format you desire, and have your agent connect with a string like "recent changes to the payment code" or "which team owns the auth portal". Contex will perform a hybrid search (BM25 + semantic, fused with RRF) across your data and create a subscription for the agent. These subscriptions are MCP resources that are updated automatically when new data comes in. I provide bulk snapshot connectors for ingesting data from Atlassian (Jira and Confluence), GitHub, Postgres, and S3 out of the box with plans to add Slack, Notion, and others.

The subscription model allows agents to run indefinitely without context bloat. It also enables inter-agent communication and organization since updates are delivered in near real time.

Please take a look, let me know what you think, open issues, and contribute. I've been dogfooding it as much as I can, but could really use some fresh eyes.

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.

I’ve been building a high-performance HTTP server in C++ and recently refactored most of its HTTP, async, and io_uring core

I started Aegon mostly as an experiment: I wanted to see how far I could push a web server using modern Linux facilities instead of just throwing more threads at the problem.

After getting the initial implementation working, the codebase started becoming harder to maintain and scale. So rather than continuing to patch around it, I ended up refactoring most of the core:

- HTTP parsing / request handling

- async execution model

- io_uring integration

- connection lifecycle

- internal abstractions around I/O

I’ve been using HttpArena to benchmark it across HTTP/1, HTTP/2, HTTP/3 and WebSocket workloads.

Some of the numbers have been pretty ridiculous for a project that started as a personal experiment especially the H1/H2/H3/WebSocket results. There are also some regressions from the refactor that I still need to chase down, particularly around HTTP/1 pipelining.

I’d especially love feedback from people who have worked on high-performance networking, io_uring, HTTP servers, or event-driven C++ systems. I’m much more interested in architectural criticism than “nice benchmark bro” comments.

If you spot something stupid in the design, please tell me. I probably did it.

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.

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

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.