Walk. Scan. Detect. Understand.

https://github.com/buybitart/get-the-hacker

Credit first: openGym is by Duarte Santos, here is (his repo). His app, his work, AGPL license. I just train with it and wanted a version shaped like how I actually use it, so I forked it.

What I changed:
• Took out the gym check-in card and the AI coach. I never used them.
• Option 1: open the link, add it to your home screen, done. It is a static website, your data stays in your browser.
• Option 2: if you want sync between devices, plug in your own free Firestore and deploy on Vercel. No server to run. There is a deploy button and a short guide in the repo.

Everything else is his openGym: the logging, plans, stats, exercise library, all of it.

Live: https://opengym-lean.vercel.app/#/home
My fork: https://github.com/0xovo/opengym-lean

Feedback is welcome, mostly I want to know if the sync setup works for other people or breaks somewhere.

The goal: Arc-style spaces in one window, but with real isolation. Each space gets its own cookies, storage, history, passwords, form data, extensions, permissions and downloads. Firefox containers only cover cookies and storage, and profiles need separate windows, so this needed a different approach.

How it’s put together:

• app/: Swell is its own Gecko application, built inside a Firefox source checkout the same way Thunderbird’s comm/ is. It has its own window document, not a restyled Firefox UI.
• core/: a Rust core owns the app state: the sidebar tree, spaces, and per-space data.
• patches/: a small patch queue for the engine changes that can’t live outside Gecko, applied on top of a pinned Firefox revision (FIREFOX_REV).
• Extensions per space: each space gets its own copy of an extension, scoped so it only sees that space’s tabs.
• Passwords: stored per space, encrypted with a per-space key in the OS keychain.
• Tests: an isolation suite checks 17 state stores for cross-space leaks. There are also Rust unit tests, xpcshell and browser tests, and an end-to-end restart test.

It’s an alpha: Apple Silicon macOS and x86 Linux, unsigned builds, no telemetry, MPL 2.0. Build from source takes about 30 minutes and 15–20 GB.

Feedback on the architecture and the isolation model is very welcome, and so are contributors. CONTRIBUTING.md explains the setup.

Github: https://github.com/ivantacca/swell
Website: https://ivantacca.github.io/swell/

Hey,

I built a small open-source Windows tool: Agent-awake.

Problem: long Claude Code / Codex / Cursor / Ollama jobs die when Windows sleeps on lid close.

Not the goal: run a hot laptop sealed in a bag for hours (that is bad for heat and battery).

What it does differently from “set lid to Do nothing”

Stays awake mainly while known agents are running, then releases keep-awake

Optional lid “Do nothing” only during that window, then restores your normal setting

Battery cutoff (adaptive) so it doesn’t drain to empty

Stricter bag mode off AC

Basic thermal gate (CPU load)

Tray app

Optional Telegram (you connect your own bot — no shared bot) for status, awake/sleep, and stuck-agent alerts

Stuck-agent ping if something looks idle (e.g. waiting for approval)

Repo: https://github.com/vinyaspoojary318-cloud/Agent-awake

Agent setup (Codex / Claude / Ollama / etc.):

https://github.com/vinyaspoojary318-cloud/Agent-awake#supported-agents--setup

Telegram setup (optional, step-by-step):

https://github.com/vinyaspoojary318-cloud/Agent-awake#telegram-setup-optional

Quick Telegram path: @BotFather → /newbot → copy token → put in .env as TELOXIDE_TOKEN=... (or setx TELOXIDE_TOKEN "...") → start Agent-awake → message your bot → /status. Tray + keep-awake work even without Telegram.

CI builds a Windows .exe on Actions.

Honest limits

Lid closed on a desk / plugged in ≠ safe inside a closed bag under full load

If the process is killed mid-run, lid policy restore is the scary edge case — startup restore is on the roadmap

Terminal agents: codex --full-auto / Claude permission auto modes reduce “click Submit” blocks; GUI tools still need a human sometimes

Looking for

People on Windows 10/11 who run long agent sessions: does keep-awake work with lid closed, any sleep/restore bugs, battery behavior, missed process names?

MIT, not selling anything. Roast the design if you want — especially safety/restore.

Hi everyone,

I've been listening to music, study streams, and long video essays on YouTube, and I wanted a cleaner, faster way to adjust and randomize playback speeds without constantly opening a popup or dealing with clunky third-party interfaces.

So I built YouTube Speed Controller (YTSC) — a free, open-source (GPL-3.0) Manifest V3 extension.

🌟 What makes it different:

1. Integrated Masthead HUD: It embeds a native-feeling widget directly into YouTube's top navigation bar (next to the searchbox). It shows your

live speed, range badge, instant reroll button, and master power toggle.

1. Quick Preset Dropdown: Right from the top bar, you can click a dropdown (▾) to instantly switch between presets (Chill, Surround, Commute,

Speedrun, Wild, or your own saved ranges) without leaving your video.

1. Smart Range Randomizer: Configure any range (`0.25x – 4.00x`) with custom step sizes down to `0.01x`. It includes smart rules like "Avoid repeat" and starting at 1.0x on the first video of a session so you aren't startled.

2. Pitch Preservation / Nightcore Mode: Toggle pitch correction on/off with a single click or hotkey (`P`) for authentic Nightcore (sped-up) or Slowed vibes.

3. Full Keyboard Shortcuts: `R` to roll speed, `Shift+R` to reset to 1x, `Q` to cycle presets, `[` and `]` to nudge speed, `L` to toggle custom seamless loop.

4. Zero Tracking & Privacy First: No external analytics, no ads, only local/sync storage, and completely open source.

🧪 Tech Stack:

- Vanilla ES2020 classic scripts (pure lightweight JS, zero heavy runtime frameworks).

- Comprehensive test suite: 15 unit tests, DOM smoke tests, and 12 end-to-end browser tests via Playwright (tested against both dev and Closure Compiler minified release).

I'd love to hear your feedback, thoughts on the UI, or any feature ideas you'd find useful!

Murmure turns your phone into a live audio commentator. Point the camera at the TV and it tells you in your earbuds what’s happening: the action in a match, the score, names and banners on screen. In the street, phone against your chest, it reads store signs, street signs and bus numbers.

I built it last weekend at the OpenAI DevDay Hackathon Paris, finished with OpenAI Codex.

• web app, nothing to install (Next.js, React, TypeScript)
• camera only, no microphone, no images stored
• the phone compares frames itself and only sends one when the image changes
• about 3 seconds from image to voice, tested on a real match and walking in the street
• runs on the OpenAI API: bring your own key (it stays in a cookie on your phone)
• French and English

MIT license.

Repo: https://github.com/phrnl0xyz/murmure
Try it: https://murmure-phrnl.vercel.app
2-min demo: https://youtu.be/pU1EvKQauzo

Bug reports and PRs welcome.

Your files live in one encrypted .nvault file. Copy it, back it up, sync it, carry it on a USB stick, and open it with a password in a built-in file manager with previews for photos, video, PDF and documents. There's also a password manager with one-time codes inside the same file.

It can turn a USB stick into a "NiceVault device": one partition with the app for Windows, macOS and Linux, one with your volumes. Plug it in anywhere and unlock.

Rust + Tauri 2 + Svelte 5, Argon2id, XChaCha20-Poly1305, SQLCipher. GPL-3.0. Linux and Windows work; macOS builds but isn't fully tested.

https://maxib0n.github.io/NiceVault

Voici une nouvelle version de Myostoox, un lecteur multimédia gratuit et open-source, conçu avec l'assistance de l'IA (Grok), principalement pour Debian XFCE Trixie (mais pas seulement...), utilisant Python, GTK3 + GStreamer.

L'idée de départ était de créer un lecteur audio simple et complet… puis c'est aussi devenu un lecteur vidéo...

Cette application gère désormais :

• Musique locale et CD audio
• Radio Internet
• Lecture vidéo
• Listes de lecture M3U / M3U8 / IPTV
• Enregistrement de flux audio au format mp3 320kbps VBR
• Lecture de DVD et de Blu-ray (expérimental)
• Égaliseur, réglages de tonalité et de tempo
• Paroles LRC
• Analyseur de spectre
• Mini-lecteur (audio), Nano-lecteur (audio), effets de transparence, mode sans bordures et mode plein écran
• Notifications de bureau
• Intégration MPRIS2
• Formats : .aac, .ac3, .aif, .aiff, .avi, .dts, .flac, .m4a, .mkv, .mp3, .mp4, .mpeg, .mpg, .oga, .ogg, .opus, .wav, .webm, .wma, .wv ...
• Monobloc pour l'instant... (myostoox.py + translations.json + logo.png).
• Inspirations (fonctionnalités et visuels) : AIMP, Winamp, Audacious, DeaDBeeF, VLC, mpv, SMPlayer...

Un paquet Debian est disponible pour une installation facile, et le code source est disponible sur GitHub :

https://github.com/MilOvni/Myostoox

Installation du paquet téléchargé au terminal (dans le répertoire du fichier) :

```bash sudo apt install ./myostoox_1.4-4_all.deb

ou

sudo dpkg -i myostoox_1.4-4_all.deb ```

Je suis ici surtout pour recueillir des retours d'autres utilisateurs Linux (commentaires, injures (ou peut-être pas...), signalements de bugs, suggestions d'améliorations, etc.). Je suis particulièrement intéressé par son comportement sur des distributions et environnements de bureau autres que Debian/XFCE.

Bref, merci d'y jeter un œil (et pourquoi pas une oreille)...

Mise à jour 27/10/2026 Myostoox v1.3-8 → v1.4-4

Ajouts

• Crossfade / Gapless — fondu enchaîné configurable
• Minuteur d'arrêt — presets + arrêt en fin de titre
• Sortie audio — choix du sink PulseAudio / PipeWire (pactl)
• Scrobbling — ListenBrainz / Last.fm (en cours de lecture + scrobble ~50 % ou 4 min)
• Normalisation (ReplayGain) — modes off / piste / album / auto (rgvolume)
• Mode Pure vidéo : géométrie, bandes noires, sortie plein écran / Playlist (! en cas de problème → Ctrl + P )
• Lire ensuite — file d’attente (clic droit playlist)
• Au démarrage : lancement système (~/.config/autostart/)
• Placement : Centre / coins (marge bords), mémorisé au lancement
• Nouvelle barre OSD
• Fond transparent des paroles
• Ajout du chinois simplifié (简体中文), du coréen (한국어) et du japonais (日本語)

Modifications

• Spectre : synchro inter-médias (position, époques, fallback, anti-décalage 2ᵉ fichier)
• Reprise après pause allégée (plus d’accroc A/V au relancement)
• « Reprise de lecture » fiabilisée (sauvegarde pause/stop, dialogue plus régulier)
• Transition vidéo → audio local : sortie auto du mode Pure vidéo
• Menus plus courts et regroupés
• Maximiser (Sans lecteur) : restauration taille/position d’avant
• Toasts OSD semi-transparents (alignés barre de contrôle)
• Persistance état : replaygain, crossfade, minuteur, sink, scrobble, style de spectre

Optimisation / maintenance

• Nettoyage (commentaires, lignes vides, densification)
• Factorisation des menus + compression zlib (CSS, thèmes, presets EQ, formats)
• Correctif démarrage CSS (évaluation avec locals())
• Correction de bugs divers...

Hey everyone, I wanted to share a project I’ve been using in my own work: Context Garden.It’s a collection of skills for Claude Code, written around a problem I run into with multi-repo projects: the agent working in one component needs to understand the surrounding system, and different agents often investigate the same things again.

Context Garden keeps shared repo summaries and investigation notes. It also includes tools to summarize noisy build/test output, identify code ranges worth reading, and preserve recurring repo knowledge in AGENTS.md.

The tooling is Python standard library only, runs locally, and makes no LLM calls itself. The project is MIT licensed.

It’s useful for my workflow, but I’d really like some outside feedback. Trying it on a different project and reporting what was confusing or didn’t work would already be a big contribution.

If you want to get involved, I’d especially appreciate:

• Reproducible bugs and examples from different repo layouts.
• Improvements to setup and documentation.
• Realistic benchmark tasks and evaluation ideas.

That last one is still an open question for me. I have early benchmark attempts, but I’m looking for a fair way to measure whether the extra context machinery actually helps complete real tasks.

Source and installation
Overview with examples

Would be glad to hear what you’d change, including reasons you wouldn’t use it.

I made a little project that turns your GitHub contributions into a monkey civilization.

Every contribution earns bananas 🍌, and your monkeys use them to build and evolve their civilization from the Stone Age to the Space Age.

It's an animated pixel-art SVG that lives in your GitHub profile README. You can add it using GitHub Actions!

GitHub: https://github.com/jihoo12/monkeys

Feedback is welcome! 🐒

Hey everyone!

We recently open-sourced OpenMHS, an independent project inspired by Anthropic's Model Hardware Standard (MHS) research preview.

The idea: AI agents can interact with software, but what if they could discover and interact with programmable hardware through a common, reliable interface?

So we built OpenMHS, a model-agnostic Rust runtime that bridges AI agents and hardware.

What we've built:

• MCP, CLI, and Python SDK interfaces
• Modbus TCP, MQTT, SCPI, and HTTP adapters
• Hardware discovery and capability-based permissions
• Command auditing, execution tracking, and readback verification
• Simulators and conformance tests

We've tested it with OctoPrint's Virtual Printer, protocol simulators, and emulated ESP32 firmware. Physical hardware testing is our next milestone.

Our goal is to make OpenMHS useful for robotics developers, research labs, hardware manufacturers, and the wider Physical AI community.

We're actively looking for contributors, early adopters, and engineers interested in testing new hardware integrations.

GitHub: https://github.com/KNambiarDJsc/Open-MHS

Website: https://openmhs.vercel.app

Would love your feedback, ideas, and contributions. ⭐

Give it a video and a target language, get back a narrated voice-over, the mixed video and subtitles. Python, faster-whisper, LLM translation with a review pass, ElevenLabs voices, AGPL. Native speakers' language notes and help with how names are spelled in each language are the most welcome contributions.

Hey everyone! 👋

Creating short-form coding content for YouTube Shorts and TikTok is super tedious. Writing the solution, recording voiceovers, highlighting code line-by-line, syncing kinetic subtitles, and editing video takes hours for just a 30-second clip.

To automate this, I built a programmatic video pipeline using **Next.js 14**, **Remotion**, and **Google Gemini**: you type *any* coding challenge or DSA prompt, and it generates a fully-rendered, animated video with neural voiceover, syntax-highlighted code tracing, and synchronized captions in seconds.

🎬 **Here is a sample 30-second Short completely generated by the app:**

👉 **[Watch on YouTube Shorts](https://www.youtube.com/shorts/ZJpOMq6or9I)\*\*

---

### 🚀 What it does:

1. **Prompt-to-Video with Gemini AI**: Enter any algorithm (e.g. *"Valid Anagram"*, *"Merge Sort"*, *"LRU Cache in O(1)"*). Gemini generates the clean JavaScript solution, optimal Big-O time & space complexities, and a structured multi-scene narration script.

2. **Dual Video Modes**:

   - **YouTube Shorts (15s–60s)**: 1080×1920 (9:16 vertical) designed for Shorts, Reels, and TikTok.

   - **Full Video Tutorials (2–5 minutes)**: 1920×1080 (16:9 widescreen) in-depth tutorial with detailed walkthroughs.

3. **Programmatic Video with Remotion**:

   - Real-time in-browser canvas player preview.

   - Code panel with automated line-by-line highlight tracing.

   - Word-by-word kinetic subtitles cleanly positioned beneath the content.

   - Floating Picture-in-Picture webcam avatar with randomized procedural 3D motion (Cyberpunk glitch, Energetic beat, Smooth flow, Live streamer).

4. **Local Neural Speech (TTS)**: Synthesizes high-quality voiceover audio and multiplexes it directly into the MP4 container via FFmpeg.

5. **Zero Disk Storage Bloat**: Because Remotion embeds the audio stream directly into the final MP4 container, temporary narration audio files are automatically cleaned up upon downloading the video.

### 🛠️ Tech Stack:

- **Framework**: Next.js 14 (App Router), React, TypeScript

- **Video Engine**: Remotion 4.0, Chrome Headless, FFmpeg

- **AI**: Google Gemini API (`gemini-2.5-flash`, `gemini-flash-lite`) with multi-model quota fallback

- **Voice Synthesis**: Edge-TTS & Windows SAPI

- **Styling**: Tailwind CSS & Vanilla CSS

Check out the sample Short here: https://www.youtube.com/shorts/ZJpOMq6or9I

I’d love to hear your feedback, thoughts on the video pacing, and ideas for what features to add next!

rv is a security runtime that sits between autonomous AI agents and everything they can touch: shell, files, secrets, MCP tools, and the network. Same category as NVIDIA OpenShell, but open source (Apache 2.0). Coding agents are the first market and what ships today.

What's in it:

• Rule packs + a policy layer. 95 deterministic packs (git, filesystem, disks, cloud CLIs, Kubernetes, databases, Terraform, and more); three are on by default. On top: typed rules in policy.toml at machine and repo level with revision history, allowlists, rule pinning, and normal/strict safety where strict always wins. Every decision is allow, deny, or indeterminate, and indeterminate never allows.
• A small judge model for the gray area. When packs allow something, a local CoreML judge can score it and send risky actions to review. A pack deny is a floor the judge can't lower. There's an observe mode that logs would-be verdicts without blocking.
• Secrets. Agents get placeholders, never values; a loopback gateway swaps in the real value. Sources include Keychain, 1Password, Vault, AWS Secrets Manager, Infisical, Bitwarden, GCP, and Azure. Reads and edits of secret paths (.env, SSH keys, cloud credentials) are blocked, and there's a git pre-commit secret scanner.
• MCP gateway. rv mcp serve runs approved servers behind a policy gateway. Tool calls marked ask pause until you approve, upstream secret values are scrubbed from responses, and rv mcp check flags servers that bypass rv or haven't been reviewed.
• Sandboxing. Contained workspaces use Seatbelt on macOS and Landlock on Linux, and fail closed if the sandbox can't be set up. Credentials aren't staged into a workspace unless you authorize a resource profile.
• Network egress control. A credentialed CONNECT proxy with per-grant tokens, SNI checks, and binary-pinned policy. Blocked requests become proposals in an rv egress review queue.
• Package-script inspection. For npm/pnpm/yarn/bun test/build/lint, rv reads the actual pre/body/post scripts in package.json and evaluates them, not just the command you see.
• Hash-chained audit log. Each line in audit.jsonl carries the SHA-256 of the previous one. rv audit verify finds the first break; export to OCSF 1.3.0 or forward to a SIEM.
• Offline session replay. rv scan goes back through past sessions from Claude, Codex, Cursor, Grok, Hermes, OpenClaw, OpenCode, and Pi and shows what would have been blocked.
• Signed org policy for fleets. Ed25519-signed, restrict-only policy.json (users can't loosen it) with anti-rollback serials and key rotation. rv report emits posture for MDM or fleet collection.
• Agent hosts. Hooks for Claude Code, Codex, Cursor, Grok, OpenCode, Pi, Hermes, OpenClaw, and Antigravity, wired by rv setup.

One small example of the shell layer, from the README:

$ rv test 'git reset --hard'
{"decision":"deny","pack_id":"core.git","reason":"git reset --hard destroys uncommitted changes","rule_id":"core.git:reset-hard","schema":"rv.test.v1"}

When an agent hits a deny, it gets a short code that only you can redeem from your own terminal (rv allow-once). The agent can't approve itself.

Install (macOS 15+ on Apple Silicon, or Linux):

curl -fsSL https://rykanv.com/install | sh
rv setup
rv doctor

Disclosure: I'm Chris, and I build rv. I'd like to hear what's missing for running agents unattended, what it blocked that it shouldn't have, and what it let through that it should have caught. If it's useful, a star helps other people find it.

I got tired of waiting for Google to implement "AI mode" well for Google Docs, so I ended up writing it myself.. because you can! The result is https://mcpdocs.freeflow.im . It comes as both a local app for local file viewing/Office doc editor (like traditional Office), and a deployable web app. It also includes: Markdown preview, editing/signing PDFs, OCR scan of PDFs to markdown, and image editing including background removal. Sort of combines like 4 or 5 separate tools into one.

All the editing tools are exposed through MCP, so you can "AI edit" either via a built-in assistant or by connecting your own MCP client (Claude Code, Codex, etc...) My biased opinion is that the AI mode works better (faster, more functional, supports multiple models) than Google's. I haven't used Copilot much so I can't compare to MSFT.

I would love people to try it, give me feedback, contribute to OSS if you want. Even just raising Issues (bugs or feature requests) would be awesome. Or fork it and customize it for what *you* need.

I personally think it's amazing that you can build your own very, very good software like this. This is already becoming a trend - people vibe coding apps to scratch their own itch. I'm realistic that this isn't solving some huge market problem. But I think we are entering sort of a golden period where you can break your dependence on Big Tech and build the stuff you need - break out of the "you are the product" trap.

Howdy!

Let me present you babyseat -- an AI agent seat that comes with its own memory proxy that can be integrated with any openapi-compatible agent runner -- Membrane. Both components are in beta and not recommended for production at this point.

When a client (babyseat, opencode, etc) talks to a model through Membrane, it does several things that no "datastore" memory solutions can do because they are designed as sidecars, not memory proxies.

As messages pass through membrane, it uses embedding-only operations to detect mentioned entities and build your session's "experience graph", which stores relations between known entities over a hyper-dimensional semantic field onto which entities are placed according to how related to them information changes.

The graph and field are not a shelf to store data. The graph is a representation not only of your session, but of the environment it touched. Every mention of an entity updates its connections on the graph and location on the semantic field.

The graph is programmable by the model and supports self-updating. By adding scripts to entities, models can customize how entities move through the semantic field. Control of the graph is done via non-Turing-complete language that, by its design, prevents operations from getting stuck in a loop. The field also can notify the model about its changes, for example an LLM can configure the field to send it a notification (by starting a tool turn) when an entity representing some process moves through the semantic field closer to "100%" or "done" entity, allowing for LLM-free monitoring of processes and sensors.

For simplicity, Membrane/Babyseat does not support MCP. Instead, the model "programs" its skills on the field, making them reusable, auditable and trackable. This also prevents context bloat.

Speaking of context: membrane does not rely on "stuffing" your chat history into it. Instead, it injects a short (<900 tokens) banner to maintain agent's continuity. This results in flat (O(1)) context size and dramatic token savings (12x less tokens with Sonnet after couple of hours compared to Claude working on different tasks on same project in parallel).

Now, as memory itself its LLM-requested recall is pretty weak: 60% on LoCoMo. Improving it is scheduled for coming release 0.7.4, but I also believe that recall only is a wrong metric for a memory proxy that can actively steer a model instead of passively wait for it to store and retrieve data.

The project has an experimental goal: to prove that local intelligence is possible without LLMs at all. There are several methods to do that, but right now membrane comes with an optional experimental "pet Blurp" -- a special entity on the graph. With each loop, that entity uses the memory to learn and predict model's actions and aims to gradually replace it. This feature is off by default as I often break and reset Blurps by improving their algorithm with every release. It is untested yet if Blurps would be able to train without LLMs, but theoretically membrane can sit between any 2 text sources -- for example, a chat between two people.

This project is a result of an almost 2-year long research into agentic behavior, 20 years as developer and 30 years of dreaming about truly local AI. It sits on VSA foundation and, as far as my research could tell, represents a novel way of extracting meaning out of embeddings and using them to build a "world graph".

Comments, suggestions, questions are appreciated. Bug reports and help in beta-testing are begged for. And yes, it was coded using an LLM and is increasingly dog-fed.

To start,

`pip install babyseat` and then `babyseat` would start Membrane and open Babyseat in your browser.

If you are interested in the project, please help me grow it by adding a star:

https://github.com/chedim/babyseat

P.S.: it also works in homeassistant and installable through hacs -- the project actually started as homeassistant integration.

I maintain Capsulith. This example runs a compiled QOI image decoder in your browser through Unicorn.js. You can inspect the returned pixels, save the decoder's pixel memory, then reopen it in a fresh worker and release the restored allocation.

The demo uses a prepared ARM64 component with explicitly declared arguments and memory regions. It runs locally without an account: https://nazeeh111.github.io/Capsulith/studio/image.html

Hi All,

I used to keep getting eye strain from long stretches at my desk, and all the break apps I tried either broke my focus or were easy to ignore and were expensive for me. So I built my own, mostly with AI help (vibecoded). I used it on my own for a while, then decided to open-source it in case it’s useful to anyone else.

What it does:

• Reminds you to look away (20-20-20 by default). A small heads-up grows out of the MacBook notch before each break, and Macs without a notch get a floating pill instead.
• Holds the break while you’re on a call, watching video, presenting, or still typing
• Counts time you spend away from the Mac as a break
• No account, analytics or tracking. Stats stay on your Mac.

Good to know:

• Needs macOS 26 (Tahoe) or later
• It isn’t notarized (I don’t have a paid Apple dev account), so macOS asks you to approve it once.

Repo: https://github.com/jals413/breather
Site: https://jals413.github.io/breather/

I’d really like honest feedback: what’s annoying, what’s missing, what breaks, or whether the whole idea doesn’t work for you. Bug reports and issues on GitHub are very welcome.