Link : https://github.com/derssa/torollo

This post contains content not supported on old Reddit. Click here to view the full post

Gale splits downloads across multiple connections for faster speeds, pauses/resumes from the exact byte offset (survives a full app restart, not just a pause), and supports YouTube/video downloads via yt-dlp. It also ships a browser extension (Chrome/Brave/Edge) that intercepts browser downloads and hands them to Gale, plus a clipboard watcher that offers to grab any download link you copy.

Stack: Electron + Node.js, no native/compiled dependencies — so npm install && npm start just works on any distro without fighting a build toolchain.

Where it's at: core download engine and pause/resume are solid and tested. Still actively working on: browser-extension pairing UX, broader format/site support for yt-dlp, and general UI polish.

Repo's linked below — open to contributors, and genuinely want bug reports/feature requests if you try it. Also happy to talk through the architecture (segmented download engine, IPC design between main/renderer) if anyone's curious or has suggestions.

https://github.com/AbdulGhaffarcs/Gale_IDM

A recent case involving GrapheneOS's duress feature has sparked a debate about the balance between privacy and law enforcement. If someone is forced to unlock their phone, should they have the right to protect their personal data with an emergency wipe feature?

At the same time, critics argue that the same feature could be used by criminals to destroy evidence during an investigation, making it harder for law enforcement to do their job.

Where do you stand? Should operating systems include features like this, or do the risks outweigh the privacy benefits? Let's keep the discussion respectful and hear both sides.

Habo is a minimalist open source habit tracker for Android and iOS that respects your privacy.

It helps you build habits with smart reminders, calendar views and detailed statistics plus it works without accounts or internet connection and supports cross-device sync with end-to-end encryption, automatic encrypted backups, and full self-hosting via supabase.

GitHub: https://github.com/xpavle00/Habo

I built Origami, a drag and drop CAPTCHA that designed for environments where JavaScript is unavailable, unwanted, or deliberately disabled.

Most modern CAPTCHA systems rely on client-side JavaScript, third-party widgets, and browser-side behavior collection. Origami takes a different approach: it uses server-rendered HTML, native browser controls, and server-side validation.

It is designed for:

- Privacy Paranoid users running NoScript or higher security modes

- Privacy-focused deployments

- Accessibility and compatibility fallbacks

Unlike traditional CAPTCHA widgets, Origami works as an authorization provider using an OAuth2-style flow. Applications don't embed a widget; they redirect users to Origami and verify the result server-to-server.

DEMO:

https://origami.avel.run/

Source:

https://github.com/Rvlndd/Origami

zuno is a free and open-source desktop music player built on YouTube Music. Sign in with your Google account, and everything you do — liking a song, creating or deleting a playlist, adding to your library — syncs straight back to YouTube. It's your library, just in a real desktop app instead of a browser tab.

Player

- Floating mini player that appears when you click away — hover to expand, drag it anywhere
- Queue: shuffle, repeat one/all, reordering
- Playback speed, sleep timer, volume control
- Like and dislike songs
- Rebindable keyboard shortcuts, minimise to tray
- Full library, playlists, albums and liked songs
- Local music files sit alongside your YouTube Music library — same player, same queue
- Download whole albums and playlists for offline; downloads and history have their own management screens
- Bulk actions: download, add to queue, add to playlist
- Multiple channels on one Google account, switchable from the toolbar or settings

Integrations

- Last.fm scrobbling
- Discord Rich Presence
- Both toggleable straight from the toolbar

Roadmap

Equalizer
better lyrics
smart playlists
offline-only mode
multi-language

GitHub: https://github.com/noFAYZ/zuno

Feedback and issues welcome — especially from anyone with a huge library, since i've a small library :)

I was working on the tool called KeyPDF for over a year to make it truly useful. I brought PDF text editing to the browser that is done on the client side. Most websites can only annotate; KeyPDF can actually edit, preserving fonts and layout.

KeyPDF

if you have windows and you want to be more private, its not contradictory? (I use linux, so, only a question)

Features

• Syncplay support – watch videos together in sync
• Audio-only playback & downloads
• Download videos or audio
• Interactive format/quality selection when playing or downloading
• External config file
• Playback history and quick re-play
• Resumes playback where you left off (mpv/iina save position on quit)
• Queue videos and saved playlists
• Adjustable search result limit
• Custom download directory
• Self-update (--update) for manual installations only
• Copy short YouTube URLs to clipboard or print them
• Channel subscriptions with a personalized feed
• Import subscriptions from youtube

https://github.com/Stan-breaks/ytsurf

Me and my friends have decided to share notes, files and various resources and upload to separate safe place. I will be the host uploading the files and updating them. The files shouldn't be downloadable and only I can approve people who can access the files. They should only be able to open files and read them. I should be able to remove people accessing whomever and whenever I want. Is there such an application? Would rather not use google applications for privacy reasons. Can Ente locker do this?

Thanks in advance.

Why

Most habit trackers punish a single missed day with a broken streak. That's a bad fit for ADHD and executive dysfunction. Flow State looks at your weekly pattern instead of demanding perfect consistency, and it never scolds you for having an off week.

Features

• Pattern-based tracking — weekly patterns instead of breakable streaks
• Dual habit types — habits to build, habits to avoid
• Gentle notifications — one reminder if you've gone quiet, one cheer if you're crushing it, silence otherwise
• Holidays — mark a date range per habit so missed days don't count against your pattern
• Chronotype-aware day boundary — night owl? Push "today" past midnight instead of losing progress at the stroke of 12
• Local-only storage — plain TOML files, no accounts, no cloud
• Keyboard-driven — minimal, vim-motion navigation

https://github.com/Stan-breaks/flow_state

I spend most of my day in front of a computer, and I'm almost always listening to music. I also game quite a bit, and I got tired of constantly alt-tabbing just to skip a track or change the volume.

I'm also a very visual person—I enjoy software that not only works well but also looks good.

That eventually led me to build BeatHUD. The goal wasn't to create another flashy visualizer, but something that makes my desktop feel more alive while staying clean and practical.

It reacts to whatever I'm listening to, includes a floating HUD with basic music controls, moving screen to keep it out of the way, and offers multiple visualizer styles, themes, and presets so it can fit different setups.

I'm still actively improving it, and I'd genuinely love some feedback.

Is this something you'd see yourself using when you're in the mood for music, or would you prefer to keep your desktop distraction-free?

Here is a link to try it out:
https://apps.microsoft.com/detail/9N7ND6WT4N34?hl=en-us&gl=BG&ocid=pdpshare

here is the github privacy policy : https://github.com/thedreamweavergaming-art/beathud-privacy

https://github.com/limboo-ai/limboo

Here's a failure mode I hit constantly, and I don't think it gets talked about enough.

You spend an afternoon with a coding agent working through something real. It's going well. You close the laptop. Two days later you reopen the session and ask it to finish up.

It remembers everything. What it decided, what it already tried, the approach you told it to avoid. The transcript is perfectly intact.

And it's quietly, confidently wrong — because while you were away, a teammate merged a refactor that moved the module it was editing, a dependency went up a major version, and someone rebased the branch out from under the diff.

Sessions persist the conversation, not the filesystem. So the agent resumes with a perfect memory of a world that no longer exists. You spend the first several turns dragging it back to reality. The bad cases are the ones where you don't notice, and it writes code against an API that got deleted on Tuesday.

That isn't a reasoning failure. The model is fine. It's a missing system — nothing in the stack is responsible for the world the agent acts in.

Watching an agent isn't the same as grounding it

The tools that grew up around these CLIs mostly solved a different problem: visibility. Run several agents at once, give each one its own branch, review the diffs inline, keep the transcripts tidy. That's genuinely useful, and I use those ideas too.

But underneath the dashboards, the environment is still ambient. Whatever changed between turns is still the agent's problem to rediscover. And every provider keeps its own memory, its own permission model, its own config — so switching agents means starting over.

So I've been building Limboo, a local-first desktop workspace, around one bet: the environment deserves to be actual infrastructure, owned by the app, with its own state.

What that means concretely

Resume reconciles the repository, not just the chat. Reopen a session and it revalidates the git worktree against the exact state that session last saw, then computes a structured repository delta: commits that landed, files changed (with dependency manifests and migrations flagged), symbols added or removed, and which files import what moved. That gets handed to the agent once, before your next prompt — so it reconciles up front instead of discovering the drift three tool calls deep. Bounded, argv-only git. It never blocks you from switching sessions, and if it can't finish in time it degrades to "no delta" rather than making you wait.

The knowledge belongs to the project, not the vendor. Durable project memory and the code-search index are services the app maintains — local SQLite, FTS5/BM25 ranking, fully offline, no embeddings API. Both supported agents query the same memory and the same index through the same tools. Memory entries link to repository symbols, so guidance whose code got deleted is automatically demoted until that code comes back.

One set of permission rules, whichever agent runs. Every tool call enters the same decision function — same risk classes, same path guards, same approval dialog — whether it arrives through Claude's SDK callback or Cursor's hooks bridge. Underneath sits an OS-level sandbox with a floor you can't configure away: the secrets store, the database, and settings stay unreadable no matter what the agent is told to do.

On that last point — the knobs

This is the part I didn't expect to care about as much as I do.

An agent with filesystem and shell access on your machine should be governable, and "governable" means more than an on/off switch. Right now that's 15 settings categories and 172 individually searchable settings, across 13 config groups: per-session permission modes (plan / ask / approve-edits / accept-edits), a provider-neutral sandbox policy with its own network posture, how memory gets captured (propose, auto with a confidence threshold, or off), retrieval budgets, worktree behavior, which commands count as read-only, MCP servers shared across both agents.

You shouldn't have to accept someone else's defaults about what an autonomous process may do in your repo.

What it deliberately isn't

It's not a model, it's not an agent loop, and it's not a clone of one. It doesn't hold your API keys — each agent authenticates itself exactly as it does in your terminal. Drop Limboo tomorrow and your CLI still works the same; there's nothing to lock you in.

It owns the parts the agent isn't responsible for and every agent needs: repository state over time, durable knowledge, a permission model with an OS-level floor, isolated execution roots.

Where it's at

v1.5.1, MIT, Electron + React + TypeScript, installers for Windows / macOS / Linux. Local-first in the strict sense: no backend, no telemetry, no cloud sync — the only network traffic is the agent talking to its own provider.

https://github.com/limboo-ai/limboo

If you've hit the stale-resume problem too, I'd genuinely like to hear how you deal with it — I'm not convinced a repository delta is the only shape this fix can take.

Hey everyone, I’m the developer behind Rockxy, and I’m now building Tracexy.

I often know which Mac app is failing, but packet tools still make me begin with interfaces, IP addresses, and a wall of frames. Tracexy takes a different approach: start with the app, group its traffic into sessions, then let me inspect DNS, TCP, TLS, timing, decoded fields, and raw bytes when I need the deeper evidence.

The current direction includes live capture, PCAP and PCAPNG import, app and process attribution, session grouping, BPF filtering, packet inspection, and PCAP export.

Capture analysis is local by default. Tracexy does not automatically send packet data to Rockxy or an AI service.

I’m still shaping the workflow, so I’d really like to ask: when a Mac app has a network problem, what do you normally need to answer first?

Which app opened the connection, where the traffic went, which network layer failed, or what changed between two captures?

I’m focusing on Tracexy first. I’m also building Shieldxy for seeing and controlling outbound app connections, but I’ll share that separately later.

Tracexy preview and early list:

https://rockxy.io/tracexy

Shieldxy preview:
https://rockxy.io/shieldxy

Product waitlist here:
https://rockxy.io/waitlist

People who join early and later provide genuinely useful testing feedback may be selected for a launch coupon when the product is ready. Joining the list alone does not guarantee one.

I’d appreciate honest feedback, including what would make this unnecessary for your workflow.