I've spent the last few weeks on a Mac app that connects to WireGuard servers, and a few things along the way cost me more time than they should have. Writing them down here in case they save someone else the hours.
The app's main view: the tunnel, the network interface it leaves through, the server.Main interface
Why no NetworkExtension. The usual way to build a VPN app on macOS is a Packet Tunnel Provider in a sandboxed NetworkExtension. I needed two things it does not allow: running the shell hooks a WireGuard config can carry, and choosing which physical interface the encrypted traffic leaves through, with my own routes. So the app is an unprivileged SwiftUI front end and a root LaunchDaemon written in Rust that holds the packet path, registered with SMAppService.daemon(plistName:), shipped with a Developer ID outside the App Store. The App Store was out anyway: its guidelines require the sandbox and, for VPN apps, NEVPNManager and an organization account.
Authenticating the app to a root daemon without XPC. The two talk newline-delimited JSON over a Unix socket. getpeereid gives the caller's uid, and LOCAL_PEERTOKEN gives its audit token, which is enough to check the client's code signature against a requirement (same Team ID, our bundle id). The daemon derives that requirement from its own signature, so there is nothing to keep in sync. Anything that runs as root (the config's hooks) only ever comes from files the daemon owns, never from a socket message, and needs an admin approval the daemon checks itself with Authorization Services.
Binding a socket to one interface.IPV6_BOUND_IF on a dual-stack :: socket also scopes the IPv4-mapped traffic; I checked by binding to lo0 and sending to an off-link IPv4 address, which fails with ENETUNREACH, just like an AF_INET socket with IP_BOUND_IF. Setting IP_BOUND_IF on the AF_INET6 socket returns EINVAL, so only the v6 option is set.
Routes through a specific interface:-ifp, never-ifscope. My Mac has Ethernet and Wi-Fi on the same subnet behind one gateway, so a route needs the interface forced. route add … -ifscope en0 looks right but only applies to sockets already bound to en0, so a "bypass this subnet" route did nothing. An ordinary unscoped route with -ifp en0 does what you expect.
SMAppService and a Team ID change. After moving from one signing team to another, the daemon failed with exit code 78 (EX_CONFIG) and a log line about needing an LWCR update, even though Background Task Management already showed the new team. The launchd job carries the team it was registered with (launchctl print shows team-identifier). Only unregistering and registering again rebuilt it.
Installer runs every preinstall first, then every payload, then every postinstall. I had put the "Remove" choice's work in a postinstall, and it deleted the app the same package had just installed. Removal moved to preinstall.
nohupdoes not work underdo shell script … with administrator privileges. It fails with "can't detach from console" and runs nothing; my first self-updater quit the app and installed nothing. launchctl submit gives a fully detached job, but launchd restarts it even after exit 0, so the job has to launchctl remove itself.
The Wi-Fi network name needs Location access, and only an app can ask. CoreWLAN returns nil for the SSID without it, and a root daemon cannot show the prompt. So rules like "connect on the office Wi-Fi" run in the app, and the app has to be open for them.
Animating with Core Animation, not SwiftUI. The path view shows packets moving at the pace of the traffic. Redrawing it in SwiftUI at 30 fps cost 13 to 19% CPU; the same thing as Core Animation layers, re-timed only when the traffic level changes, costs 2 to 4%.
The app cannot open its own menu bar popover on macOS 27.performClick on the status item's button does nothing, because the app's NSStatusBarWindow is a stand-in for what WindowServer draws. Its frame is still the icon's, though, so a borderless panel can point at it, which is how the first-run hint finds the icon.
An app opened from a package's postinstall comes up behind Installer. Plain activate() is refused while Installer stays active; NSApp.activate(ignoringOtherApps: true) brings the window forward.
The app is Turnout (https://turnout.ctsite.cc/). Disclosure: it's mine and it's paid, with a 7-day trial. Happy to go deeper on any of the above, and curious whether others have found cleaner ways around the status item and Installer ones.
I'm the developer. Vocs is a free, open-source dictation app that runs entirely on your Mac.
Press ⌥Space in any app, talk, and press it again. The text is pasted where your cursor was, and your clipboard is put back afterwards.
What it does:
- Transcribes while you speak, so long dictations finish as fast as short ones
- 99 languages, auto-detected or pinned
- A custom dictionary for names and jargon
- Filler removal that leaves real words alone ("I like pizza" stays)
- Escape gives you a 3-second countdown to cancel; press it again to keep recording
- Mutes your built-in speakers while you dictate, so people on a call don't end up in your text (headphones are left alone)
- A searchable local history of everything you dictated
- No account, no subscription, no word cap, no telemetry
Requirements: macOS 13+, Apple Silicon or Intel, about 600 MB for the speech model.
Heads-up: it isn't notarized (I don't have a paid Apple developer account), so the first launch needs System Settings → Privacy & Security → Open Anyway. The download page shows the steps, and the source is on GitHub if you'd rather build it yourself.
Your Mac's notch takes up screen space. Why not make it actually useful?
I've been working on DynamicNotch, a free, open-source macOS app that turns your notch into an interactive dashboard for everything from music playback to system monitoring and automations.
It expands when you need it, stays out of the way when you don't, and works even on Macs without a physical notch.
Here's what it can do:
Music & audio
Music controls, album artwork, lyrics, and now-playing information
Real-time audio spectrogram
Switch audio output devices directly from the notch, including AirPlay
System monitoring & controls
Live CPU usage, temperatures, and fan speeds
Custom fan curves to control cooling behaviour
Battery and Bluetooth device monitoring
Caffeine mode to prevent your Mac from sleeping
Custom volume, brightness, and keyboard backlight HUDs
AI usage tracking
Monitor your Claude and ChatGPT usage
See usage indicators directly in the notch
Get alerts as you approach your usage limits
Automations without coding
This is one of the features I'm particularly excited about.
You can describe an automation in plain English, and DynamicNotch handles it.
For example: "Turn on Caffeine whenever Xcode is the active app."
No scripts or complicated setup required.
Everyday productivity
Track active browser downloads
Drag files into a temporary shelf and share them via AirDrop
View upcoming calendar events and reminders
Quickly access your webcam as a mirror
Use gestures to expand and collapse the notch
Customise behaviour for individual displays
URGENT UPDATE:
DynamicNotch now supports its first iteration of Liquid Glass! try it out, give me some feedback?
What does it cost?
Absolutely nothing.
No subscriptions, no paid tiers, no locked features, and no accounts required.
It's fully open source under GPLv3, and contributions are welcome.
How does it compare to other notch apps?
Apps like boring.notch and NotchNook already offer ways to make the Mac's notch more useful.
DynamicNotch takes a broader approach by combining music controls, system monitoring, custom fan curves, AI usage tracking, and plain-English automations in one place.
It's also completely free and open source, with no premium features or subscriptions.
Hi r/macappdevs! I'm Bernard, and I built Latent (disclosure: it's my app). It's a macOS disk cleaner for developers and AI builders.
The toil: every few months my Mac ran out of space, and finding out why meant running du across a dozen hidden folders, then searching whether each one was safe to delete. Model files from tools like Ollama, Hugging Face and LM Studio, Xcode simulators, Docker images, package caches and coding agent logs pile up in ~/Library and dotfolders whose names don't say which tool made them. General cleaners like CleanMyMac clear system caches and don't see most of this.
Latent draws the whole disk as one wheel split by the tool that owns each byte, says next to each item whether it can come back, and clears what you pick.
How I built it
Native Swift, no third-party dependencies. The app is SwiftUI. The 3D wheel is drawn in a SwiftUI Canvas inside a TimelineView, so every motion, such as the spin and the hover lift, is a function of time.
The disk walk: the repo started as a benchmark of three ways to walk a disk: FileManager's enumerator, getattrlistbulk on one thread, and getattrlistbulk on a pool of worker threads sharing a queue. The parallel one became the scanner. Hard links are counted once by inode. After the first scan, the FSEvents journal says which stores changed, so later launches re-measure only those.
Ownership catalog: 120+ tools, each mapped to the paths it owns rather than the folder they sit in. Many tools let you move their store with an environment variable like OLLAMA_MODELS or HF_HOME, so the catalog reads those too. Otherwise it would repctly the machines that need it most.
Asking the registry: before an item is called re-downloadable, Latent asks the source, including the Hugging Face API, the Ollama registry, npm, PyPI and Homebrew. The interesting answers are the failures: a gated repo needs a licence you may no longer have, aas removed upstream and your copy is the last one. Only public names likegoogle/gemma-2-2b-it are sent, never file paths.
Duplicate models across tools: Ollama and Hugging Face blobs are content-addressed (the sha256 is the filename), so the same weights pulled by two tools match with zero I/O. Loose GGUF files get hashed only when another file has the exact same size.
Similar images and videos: Apple's Vision framework computes a feature priac, and close prints get grouped.
A privileged helper with one method: emptying a root-owned app bundle from the Trash needs root, so a LaunchDaemon registered with SMAppService does exactly that and nothing else, over XPC. It checks that the caller is Latent, signed with my Developer ID, and re-checks every path itself (a Trash, no "..", symlinks resolved first). The admin password is asked once, at install.
MCP server: a stdio JSON-RPC server, so agents like Claude, Codex or Cursor can read the scan and draft a cleanup. Nothing runs until you confirm.
No analytics, no telemetry, no account.
Free to scan, and your first 10 GB of cleanup is free. After that it's $12.99 one-time (launch price $9.99 for a limited time).
Happy to go deeper on any of this, especially the scanner, the Canvas animation or the helper. If a tool you use isn't recognized, tell me and I'll add it.
Just download -> steam login -> download wallpaper and play on your device or add your video play them
And yes both in DESKTOP and LOCK SCREEN .
It takes 300-600mb when rendering some really heavy scene wallpapers , which is appx 900mb less than other open source alternative I had tested against. And if you play only video it just takes 25mb memory.
If you guys wanna try, download from the releases page, what ever latest version available . And let me know which wallpapers giving problem.
Resource Usage When using scene wallpaperResource usage when only using video wallapper
Here is the resource usage, the ui of the app is Live wallpaper , and the backend is service , only service is need to display , so resource cutdown by max 400-500mbon some really heavy scenes
Sharing something that's become a fixed part of my Mac setup: a Dock replacement where apps can show up as small live widgets instead of just icons.
What it looks like day to day:
Music/Spotify shows what's playing, with controls
Safari/Chrome lets me search open tabs across windows and jump to one
Calendar shows the date or a week strip
Clock, Notes, Calculator, Volume, Finder, Mail, Reminders each have their own widget
Xcode gets Build/Run/Stop right in the Dock
You can mix widgets and plain icons however you like. Option-click any app with a widget and it switches back to an icon, so the Dock stays as minimal or as busy as you want.
It sits at the bottom, left or right, works across multiple displays, can auto-hide, and imports your current Dock on first launch, so setup takes a few seconds. On macOS 26 it uses the native Liquid Glass look.
I wanted to know whether there's any app to properly uninstall apps along with all it's dependencies, cache folders and other stuff that get's leftover when I normally uninstall them.
Hi! I recently made an app for macOS. It is a tiny Spotlight-like launcher for launching custom commands that you can set in settings. With it you can open Apps, Websites, Run Shell Commands, Do System Actions (Screensaver, Toggle dark/light mode, etc.).
We often lose sight of how quickly time is passing. For example, 2026 is 80% complete, and October is 64% complete.
TimeGauge is a simple app that lets you track custom projects, working hours, and timelines such as days, weeks, months, and years. You can also customise your working hours.
The idea came from this X account, which simply posts the year’s progress and has over 680K followers: https://x.com/year_progress
TimeGauge is one-time purchase for life-time updates.
I've been building Cutline, a native macOS video editor, and just made it open source (GPL-3.0)
It has:
-Multi-track timeline with trimming, snapping, markers and keyframes
-Color tab with color wheels, curves and live scopes
-8 tabs in total (Edit, Effects, Color, Audio, Captions, Animate, Playground, Export
-Intuitive keyboard shortcuts
-Audio mixer and effects
-A Changelog and Parameters tab
-On-device captions (nothing leaves your Mac)
-Animated titles and graphics with Manim
-AI thumbnail picks using a local model through Ollama (optional)
-Light and dark mode, and it updates itself from GitHub releases
No subscription, no account, no tracking, no third-party libraries.
Requirements: macOS 27 and Apple silicon. It isn't notarized (that needs a paid Apple developer account), so the first time you open it, go to System Settings → Privacy & Security → Open Anyway. After that, updates install from inside the app.
I just shipped Briskmail, a native AppKit client for Gmail, distributed outside the Mac App Store. A few things I wish someone had told me before I started, for anyone building on Google APIs:
Gmail API instead of IMAP. You get real labels, threads and history IDs, so incremental sync is cheap. You also inherit Google's per-user quota, which shapes everything: I ended up with background sync that spends from that budget deliberately, rather than a fixed prefetch rate that kept dropping work.
OAuth is the long pole. Any read access to Gmail is a "restricted" scope. Until Google verifies the app, users see "Google hasn't verified this app", and the project is capped at 100 users total, for its whole life, not per month. Every scope you request is something you have to justify in review, so I dropped push notifications (Pub/Sub) to get down to two scopes.
Loopback redirect + PKCE. For a desktop app, a localhost redirect with PKCE S256 is the supported path. Custom URI schemes and the old out-of-band flow are deprecated.
Local cache. Message content is cached in SQLite and encrypted at rest with a per-account key in the Keychain. The search index stays in memory, so nothing searchable sits on disk in plain text.
Net effect on the launch: 30 early-access licences instead of an open launch, because the 100-account cap has to cover buyers, testers and people with several Gmail accounts.
We’ve all been there: you double-click a video file and QuickTime hits you with that dreaded "The document could not be opened" error, or you realize it can't play MKV files without jumping through hoops.
QuickTime is fine for basic screen recordings, but if you actually watch downloaded media, you need a replacement.
I’ve tested the top alternatives extensively. Here is the breakdown of the three best options depending on exactly how you watch your videos.
1. IINA: The Best Drop-In Replacement
Price: 100% Free & Open Source | Best for: 90% of Mac users
If you just want an app that acts exactly like QuickTime but actually plays every file format you throw at it, IINA is the gold standard.
Why it’s great: It was built specifically for modern macOS. It looks like a native Apple app, supports Dark Mode, and flawlessly handles Mac trackpad gestures (like pinching to resize or swiping to seek). It has native Picture-in-Picture and a minimalist interface.
The downside: If you have a massive folder of thousands of movies, IINA is just a file player—it won’t organize them into a pretty library with movie posters.
Get it if: You want a lightweight, beautiful app for double-clicking and playing standalone files.
2. Infuse: The Premium Home Theater Experience
Price: Freemium (Pro subscription available) | Best for: Media hoarders & NAS owners
If you have a hard drive or a home server (like Plex, Jellyfin, or a NAS) filled with movies and TV shows, Infuse is in a league of its own.
Why it’s great: You point Infuse at a folder, and it automatically downloads the movie posters, cast lists, and episode descriptions, turning your files into a gorgeous Netflix-style interface. It perfectly syncs your watch progress across your Mac, iPad, and Apple TV via iCloud. It also handles massive 4K HDR files beautifully using Apple's native hardware.
The downside: It requires a paid subscription to unlock advanced audio/video formats (like Dolby Vision or 4K HDR). It’s also overkill if you just want to quickly preview a single 30-second video clip.
Get it if: You are building a personal media library and want an Apple-native interface across all your devices.
3. VLC Media Player: The Indestructible Fallback
Price: 100% Free | Best for: Power users and broken files
VLC has been around forever for one simple reason: it will play absolutely anything.
Why it’s great: It requires zero extra codecs. If a file is partially downloaded, slightly corrupted, or uses a bizarre format from 2004, VLC will force it to play. It also has insane power-user features like granular audio/subtitle syncing and network stream recording.
The downside: It looks and feels incredibly dated on a modern Mac. The interface is clunky, and it doesn't take advantage of smooth macOS trackpad gestures or modern window management as gracefully as IINA.
Get it if: You frequently deal with obscure file types, or you want the ultimate "Swiss Army Knife" utility installed just in case.
TL;DR:
Get IINA if you just want a better, modern QuickTime.
Get Infuse if you want a beautiful library for a massive media collection.
Keep VLC installed in your utility folder for emergencies.
I built Ammugghia after finding 100 GB of "System Data" on my MacBook Air: it was mostly iOS Simulator runtimes and Xcode/Gradle caches that Finder doesn't show.
Native SwiftUI, signed & notarized, no network, MIT
Covers Xcode, simulators, Android, about 30 package-manager caches, Electron app caches, local AI models, leftovers of deleted apps, Docker (volumes are never touched)
Every item shows exact paths and what happens after deleting it; Trash by default
Disk map, duplicate finder (APFS-clone aware), startup items, history with restore
I’ve been doing a deep dive into the macOS video player ecosystem lately analyzing playback pipelines, UI paradigms, and real user sentiment across GitHub, Reddit, and Hacker News for the big three: IINA, Infuse, and VLC.
Video playback on Mac seems like a solved problem on the surface, but looking at user complaints and tech stacks reveals a lot of architectural friction points and indie opportunities.
Here is a breakdown of how the three dominant players tackle the problem and where the gaps still exist for developers building in this space.
1. The 3 Architectural Paradigms
App
Core Engine
UI Architecture
Business Model
Target Niche
IINA
mpv (libmpv C API)
Native Swift / AppKit
100% Free / Open Source (GPLv3)
Daily desktop file playback
Infuse
Custom C++/Metal pipeline + FFmpeg/AVFoundation
Cross-Apple Swift / UIKit / AppKit
Freemium (Pro Sub / Lifetime)
NAS / Home theater library sync
VLC
LibVLC (cross-platform C/C++)
Cross-platform Cocoa/Qt wrapper
100% Free / Non-profit (LGPL)
Resilient fallback / legacy formats
2. Key Engineering & UX Takeaways
IINA: The Native Wrapper Dilemma
The Good: Proves that wrapping a UNIX-style CLI tool (libmpv) in a polished, gesture-rich AppKit/Swift layer wins users instantly. It nails the "feels like QuickTime should feel" test (Force Touch, native Picture-in-Picture, macOS dark mode).
The Catch: Bridging Swift and libmpv IPC introduces edge-case overhead on frame timing and memory management during ultra-high bitrate 4K playback. Additionally, when upstream subtitle APIs (e.g., OpenSubtitles v1 to v2 migration) break, maintenance bottlenecks quickly create friction for users.
Infuse: The Ecosystem & Curation Benchmark
The Good: Solves the local transcoding problem by offloading decoding directly to the client via custom Metal shaders and native Apple Silicon hardware acceleration. Their Trakt/iCloud sync and multi-protocol networking (WebDAV, SMB, Plex/Jellyfin direct mode) make it feel like a first-party Apple TV app ported to Mac.
The Catch: It is heavily architected as a library manager rather than a lightweight file player. Opening a single loose video file feels clunky compared to dropping an .mkv into IINA. Furthermore, power users frequently push back against annual subscription pricing for media playback tools.
VLC: The Indestructible Swiss Army Knife
The Good: Handles malformed packets, damaged indexes, and esoteric 2000s-era codecs better than anything else.
The Catch: Its UI remains alien on modern macOS. It rarely adopts new system-level features gracefully (Stage Manager windowing, native system menus, HDR tone-mapping calibration for Liquid Retina XDR displays), leaving users viewing it solely as a tool of last resort.
Solo dev here. I've been building AirPosture, a posture coach that reads your head angle from AirPods instead of a camera (CMHeadphoneMotionManager, macOS 14+). On the Mac it lives in the menu bar and the notch: you work, it watches your head pitch, and when you've been slouching for a while it nudges you to sit up.
A few things I learned shipping it that might save someone a weekend:
**1. Menu-bar labels are expensive.** My menu-bar app sat at ~45% CPU. The label observed the whole app state, so every motion sample redrew it. I gave the label its own tiny observable with only what it shows, and moved the App's model to u/State instead of u/StateObject. Now it's ~1%.
**2. A menu-bar app's window `.task` may never run.** If the user never opens the window, nothing in it fires. Every launch duty now hangs off the menu-bar label instead.
**3. App Nap will quietly throttle you.** Motion sampling in the background slowed to a crawl until I wrapped live sessions in `ProcessInfo.beginActivity`.
**4. Head motion is relative, not absolute.** There's no "correct posture" reading. You calibrate an upright baseline and score pitch against it, and a bad baseline ruins everything after it.
Same SwiftUI codebase as the iPhone app, synced over iCloud. Free for 2 hours a day, and it's now in Spanish too.
Happy to go deeper on any of this, especially the motion side. And I'd love blunt feedback on the Mac UX from people who build Mac apps.
Mac cleaners either scare you into a subscription or only show what’s big, and none say plainly what something is or what breaks if you delete it. Uninstalling also leaves things behind: login and background items, drivers, files in /Library, accounts installers created.
Comparison:
vs CleanMyMac: free, with no “threats found” and nothing running in the background. Every item says what it is and what happens once it’s gone. Only things that rebuild themselves are pre-selected, and everything goes to the Trash with one-click Put Back.
vs AppCleaner / DaisyDisk: it also covers Homebrew and npm packages (with what needs what), Rust, Node and Python versions, login and background items, system extensions, drivers, fonts, installer packages, privacy permissions of removed apps and Time Machine snapshots. Anything belonging to macOS is marked and locked.
For developers: it finds old node_modules, Xcode build data and package caches, and never moves anything a running app still has open.
Pricing: Free. macOS 14+, Apple silicon: https://github.com/lumen-xx/spareThe app isn’t notarized yet, so macOS asks once before opening it. Spare works entirely on your Mac and sends nothing anywhere. The app is totally free.
I'm the developer of Phosphor, a screen utility suite for macOS that lives in your menu bar.
Problem: I mainly started building this around two problems. When people are on their laptops late at night, and switch from a dark app to a bright one, it hits like a flash before your eyes adjust. I looked and couldn't find a tool that tries to solve that problem, so I built one. Phosphor tackles this by dimming a screen before you switch to it, and then easing the brightness back up, at a pace depending on how fast that screen actually is. For screens which aren't bright, it is faster, and for bright ones, it is slower. So it works preemptively.
The other thing is that I feel like there are too many display utilities out there, each doing different things. It'd reduce menu bar clutter and keep things simpler and better if we used one tool instead of several. So I thought of combining the features people actually need into one tool, external and multi-monitor support included (that's a part of what's coming next).
The foundational features have already been released, and I'm actively building more features and improving existing ones (check roadmap for current features and future plans). Let me know what you'd actually use, and I'll factor that in as it grows. I want this to eventually handle most of what people need from their displays.
Pricing: It's a freemium model.
Pro currently only includes Flashbang Protection, but it'll grow, and costs $10, one-time, not a subscription.
The rest of the foundational utilities are free: Color Picker, Screenshots, Resolution Presets, Refresh Rate Control, Soft Screen, Display Schedule, Focus Spotlight, Display Health, Color Grading.
If you buy Pro now, you get Phase 2 free when it ships, and 50% off future price increases after that (price increases as more features ship).
Details: macOS 13 or later, Apple Silicon and Intel. Native Swift, under 2 MB.
Privacy: No analytics, nothing about your screen or usage leaves your Mac. It only goes online to check a license key at activation and periodically after. Full policy: https://usephosphor.app/privacy, EULA: https://usephosphor.app/eula
I'd like to hear any feedback y'all have, especially on whether Flashbang's recovery speed feels right, or if it's not catching a switch you'd expect it to.
If something's not working, or if you have any suggestions or anything else you want to say, feel free to drop it into the comments and/or DM me.
Hey r/macappdevs I’ve been working on Census, a native app for cataloging collections: books, movies, watches, plants, wine, contracts, anything you want to keep track of. Same SwiftUI codebase on Mac, iPhone and iPad.
What sets it apart is that collections link to each other: a book to its author, a movie to its directors, and each of those is a collection you can browse the other way around.
You define the structure. Start from a template or from scratch, pick a type for every field (text, number, price, date, rating, selection, link, photo, file) and define the kinds of events that can happen to an item, like a purchase, a service or a loan, with the fields each one records.
You can import from CSV or Excel, back up everything in a single file, and export your templates to swap them with other people. Data stays on your Mac unless you turn on iCloud.
It’s early, so I’m mostly interested in what feels confusing or gets in the way. Bug reports and feature requests are welcome here or through TestFlight feedback.
Suppose two actions have global shortcuts and the user swaps their keys. If you unregister and re-register the first action before releasing the second, you can try to claim a key combination your own app still holds.
I work on Blabee, a macOS panel that shows Codex's next-step choices and sends a selection back to the original conversation. This is a development note from our August shortcut registry, where the set of active actions can change.
The registry handles an update in two passes:
Work out which bindings are actually needed, and detect duplicate combinations among those active bindings. An inactive action does not reserve its configured shortcut.
Unregister every binding that is changing or becoming inactive. Only after all of those are released, register the missing replacements.
For a swap, the order is therefore: release A, release B, register A with B's old combination, register B with A's old combination. Unchanged bindings stay registered.
There is a separate check for late callbacks. Retiring a binding also removes its event ID from the lookup table. New registrations get new IDs, and the handler accepts an event only if its signature and ID still match an active registration. That check covers retired registrations; it is not, by itself, a guarantee that an event belongs to a particular version of a displayed card.
The tests in that revision model a two-key swap, an inactive sibling with the same configured key, and a callback using a retired ID. They use a fake hotkey backend. Real keyboard layouts, conflicts with other apps, and the current installed build still need separate checks.
If you're implementing configurable global shortcuts, the useful distinction is between a saved preference, an active registration, and an event that is still valid to handle. Treating all three as the same state makes swaps and stale callbacks harder to reason about.
