Secretive is a macOS application that stores SSH private keys in the Apple Secure Enclave (or on smart cards such as YubiKeys) and exposes them through an SSH agent, making private key material non-exportable by hardware design. The architecture is a main SwiftUI management app (Secretive) plus a background login-item agent (SecretAgent) that owns a Unix socket at ~/Library/Containers/.../socket.ssh. SSH clients connect to this socket; the agent parses the SSH agent wire protocol, matches the requested key, enforces the key's access-control policy (Touch ID, Apple Watch, or password), has the Secure Enclave produce the signature, and returns an OpenSSH-formatted response. All untrusted input parsing (agent messages, certificate files) is delegated to sandboxed XPC services with hard-coded code-signing requirements, and network access for update checks is isolated to a dedicated XPC service with a declared Internet Access Policy. The code is Swift 6 with strict concurrency, strict memory safety, and warnings-as-errors, and has zero third-party dependencies by explicit project policy. The codebase is organized into small Swift packages: SecretKit (protocols and type erasers for secrets/stores), SecureEnclaveSecretKit and SmartCardSecretKit (concrete key stores), SSHProtocolKit (binary encoding/decoding of OpenSSH keys, certificates, signatures, and the agent protocol), SecretAgentKit (the agent, socket controller, authentication batcher, request-provenance tracer), XPCWrappers (a typed Codable RPC layer over NSXPCConnection), SettingsKit (keychain-backed settings), and Brief (semver update checking). Several of these are cleanly isolated: OpenSSHReader, SemVer, the FormatStyle data formatters, the keychain-backed SettingsStore, and the typed XPC session wrapper could be lifted into new projects largely untouched. The signature writer's mpint encoding correctly handles OpenSSH's signed-bignum rules (stripping leading zero bytes, prefixing 0x00 when the sign bit is set), which is subtle and covered by dedicated tests. Tests use real captured binary fixtures for protocol compatibility and cover agent identity listing, signing, witness objection behavior, authentication batching, and update selection logic. CI runs tests, CodeQL, nightly notarized builds, and attestation-backed auditable releases. Minor soft spots include duplicated certificate-migration code, two different SecretAgent entry points (SwiftUI App and AppDelegate), and a parsed-but-disabled session-bind extension, indicating ongoing refactoring rather than architectural debt.
CotEditor is a native macOS text editor written in Swift, designed for code editing with syntax highlighting, file management, find/replace, and scripting support. It uses a hybrid AppKit/SwiftUI architecture, with core editing logic in the EditorCore package, syntax parsing in the Syntax package (supporting both regex-based and tree-sitter incremental parsing), and macOS-specific UI controls in the MacUI package. The application follows an MVVM pattern with @Observable models, async task-based background processing, and extensive localization across 19 languages. Key entry points include the DocumentWindow and DocumentViewController for the main editing interface, the SettingsWindow for configuration, and the command-line tool `cot`. Data flows involve file opening with encoding detection, syntax highlighting via incremental parsers, find/replace operations with progress tracking, and remote editing via the rmate protocol. External dependencies include tree-sitter grammars for 20+ languages, Sparkle for updates, and various macOS system APIs. The codebase demonstrates strong engineering practices: modular package design, protocol-oriented interfaces, reactive state management, and comprehensive test coverage. It is actively maintained with frequent releases and security fixes.
TablePro is a native macOS and iOS database client built with SwiftUI and AppKit, designed as an open-source alternative to commercial tools like TablePlus. It supports a vast array of database engines (PostgreSQL, MySQL, MSSQL, Oracle, MongoDB, Redis, Snowflake, ClickHouse, DuckDB, Teradata, Trino, etc.) through a plugin-based driver architecture defined in TableProPluginKit. The application features a custom code editor (CodeEditSourceEditor) with tree-sitter syntax highlighting, line folding, minimap, and Vim mode; a powerful data grid for inline editing; SSH tunneling with multi-factor authentication; CloudKit-based sync for connections and settings; and an integrated AI assistant with MCP (Model Context Protocol) server support for agentic database interactions. The codebase is actively maintained, demonstrates high engineering craftsmanship with clean protocols, extensive unit and UI tests, and many reusable components that could be extracted into independent libraries.
XcodesApp is a native macOS SwiftUI application for discovering, downloading, installing, selecting, and uninstalling multiple versions of Apple's Xcode, including management of the iOS simulator runtimes that ship with them. The app surfaces a list of available Xcode versions (from the Xcode Releases API or the Apple Developer portal), drives the full install pipeline (download via URLSession or the bundled aria2c, verify code signature, unxip archive, move into /Applications, run elevated post-install steps), switches the active developer directory, and supports Apple ID sign-in with 2FA, SMS, security keys, and federated authentication. This repository is the app shell and privileged-helper layer; core domain logic and authentication live in the separate XcodesKit and XcodesLoginKit packages. The architecture is a clean three-part split. Xcodes/Backend holds a central observable AppState coordinator and small subsystems (downloader, helper client, process runner, dependency-injection environment); Xcodes/Frontend is a SwiftUI view layer organized into list, info pane, sign-in, and preferences modules; com.xcodesorg.xcodesapp.Helper is a separate privileged XPC service installed via SMJobBless, with peer connections verified by code-signing designated requirements and audit-token comparison before any xcode-select, license-accept, or file-operation work is performed. Update delivery uses Sparkle with a Jekyll-generated appcast hosted on GitHub Pages. The codebase is well engineered for a GUI app: the Environment/Current dependency-injection seam makes nearly all side effects mockable, and the test suite is unusually thorough, covering SRP authentication vectors from real Apple ID sessions, stale-async-task race conditions, new-version notifications, and download/install state transitions. The main weaknesses are the reliance on the private NSXPCConnection.auditToken API, several SPM dependencies pinned to main branches, some duplicated view helpers and stale branding text (RobotsAndPencils references, a hardcoded WWDC 2022 status message), and a manual multi-step release process. Maintenance is active: recent commits, CI running on the latest macOS/Xcode runners, Dependabot config, release-drafter workflow, and xcstrings localization validation. Technical drift is low — the code aggressively tracks current Apple platforms (macOS 26 branches, Xcode 26.5 CI), though the private-API usage and main-branch dependency pins remain chronic medium-term risks.
Mole is a macOS system maintenance CLI tool that provides a unified interface for cleaning caches, uninstalling applications, analyzing disk usage, monitoring system health, and optimizing performance. It combines two Go binaries (cmd/analyze for disk exploration with a Bubble Tea TUI, cmd/status for real-time system metrics) with an extensive shell script library for orchestration and system-level operations. The `mo` command dispatches to subcommands like `clean`, `uninstall`, `analyze`, `status`, `optimize`, `purge`, and `installer`. The architecture is hybrid: Go handles performance-critical tasks (concurrent directory scanning with semaphore-based concurrency, hardlink deduplication, gob-based caching, and interactive TUI rendering) while Bash scripts manage cleanup logic, safety guards (path identity snapshots, whitelists, process guards), Homebrew integration, and sudo session management. Key data flows include disk scanning with progress events and cache invalidation, system metrics collection via gopsutil and macOS commands (system_profiler, ioreg, pmset), and cleanup operations with dry-run previews and bounded timeouts. External dependencies include Homebrew (for cask detection and uninstall), macOS system commands (tmutil, plutil, diskutil, osascript), and Go modules (charmbracelet/bubbletea, lipgloss, gopsutil). The codebase emphasizes safety with fail-closed policies, identity re-verification before deletion, and extensive timeout handling. It supports both interactive TUI and non-interactive JSON output for scripting.
PureMac is a free, open-source macOS system cleaner and app uninstaller built as a native SwiftUI application (targeting macOS 13.0+). It provides a graphical interface and a companion CLI tool for scanning and removing junk files, uninstalling applications with full leftover cleanup, finding orphaned files, and performing scheduled maintenance. The system is architected with an MVVM-like pattern: a central `AppState` ObservableObject drives all UI state, while modular actors (`ScanEngine`, `CleaningEngine`, `BinaryThinner`) handle async scanning and cleaning operations with safety checks (path allowlists, symlink resolution, trash-only deletion). The app uses a 10-level heuristic to match app files, scans 12+ categories (system junk, user cache, Xcode, Homebrew, Docker, AI apps, etc.), and integrates with macOS services like Full Disk Access, Finder Services, Menu Bar, and Sparkle auto-updates. The CLI is a separate Swift package with its own set of commands (clean, purge, analyze, optimize, ignore, config) that reuses similar logic, ensuring consistency between GUI and terminal workflows. The codebase is well-structured, fully internationalized (10+ languages), and distributed via Homebrew and GitHub releases with a full CI/CD pipeline for signing and notarization.
MonitorControl is a macOS menu-bar utility that controls external displays' brightness, contrast, and volume. It does not just send one kind of command; it uses multiple control paths: hardware DDC/CI over IOKit I2C on Intel Macs, DDC/CI over IOAVService on Apple Silicon, Apple's private DisplayServices API for Apple/Thunderbolt displays, gamma-ramp adjustments for software dimming, and transparent shade windows for virtual displays. User input flows from native media keys, custom keyboard shortcuts, and menu-bar sliders into a DisplayManager singleton, which coordinates native OSD overlays, smooth brightness transitions, and cross-display synchronization. The app uses Sparkle for updates, SimplyCoreAudio for audio device handling, MediaKeyTap for media-key interception, and KeyboardShortcuts for user-defined bindings. Architecturally, this is a classic Cocoa application with a storyboard-based preferences UI, a login helper app (MonitorControlHelper), and a clean separation between models (Display, AppleDisplay, OtherDisplay), support services (DisplayManager, DDC backends, OSD utilities, media-key handling), and view controllers for preferences and onboarding. Entry points are main.swift, AppDelegate, DisplayManager, and MenuHandler. Persistence is UserDefaults backed through a PrefKey enum, and the UI is localized into 19 languages. There is no data/research component; this is purely an end-user utility. The codebase is modular and well organized, with the DDC communication isolated into Intel and ARM backends and display-specific logic abstracted behind a base Display class. It is actively maintained, with recent commits and a modern dependency setup. Technical drift is medium rather than low because much of the functionality depends on private or undocumented macOS APIs (DisplayServices, CoreDisplay, OSDUIHelper) and the code contains many macOS-version-specific workarounds, but the project tracks current macOS releases and continues to update its fallbacks.
Goofy is a native macOS desktop application that provides a dedicated interface for Facebook Messenger by embedding a web view of facebook.com/messages and enhancing it with native features. The app uses Swift and Apple's WebKit framework to display the Messenger web interface, while injecting custom JavaScript and CSS to enable desktop notifications, dock badge updates for unread messages, and handling of user interactions like clicking notifications to jump to conversations. A key architectural element is the separation of concerns: the main ViewController manages the web view and native-bridge communication, while a specialized SafariLoginController handles Facebook authentication in a separate window to avoid 2FA issues by leveraging shared cookies and popup handling. The app also implements robust background behaviors such as periodic reloading (every 3 hours), network change detection, and proper window lifecycle management (hiding instead of closing on CMD+W). Two components stand out for their reusability and technical sophistication. First, the SafariLoginController (SafariLoginController.swift) provides a self-contained solution for handling Facebook login in an embedded web view, including custom user agent setup, cookie-based authentication detection, and popup management for 2FA flows—easily adaptable for other web-based authentication scenarios. Second, the observe function in content.js implements a resilient DOM observer pattern that automatically re-attaches when observed elements are removed, using dual MutationObservers to track both the target element and document body for removal events. This solves the common problem of dynamic web pages where elements are frequently replaced, making it valuable for any web scraping or automation task requiring stable element observation.
Claudoscope is a native macOS menu-bar application that serves as an observability and configuration management dashboard for Claude Code, Anthropic's AI coding assistant. It reads local Claude Code session transcripts (JSONL), caches parsed summaries in a GRDB-backed SQLite store, and presents analytics on token usage, cost, cache effectiveness, model distribution, and attribution per skill, MCP tool, or agent. The app also includes a comprehensive configuration linter (100+ rules for security, skills, hooks, routing, hardening, and more), an installer for Claude Code hardening baselines and agent routing stacks, real-time file monitoring via FSEvents, and an optional MCP server that exposes read-only tools for AI-driven querying. It operates as a background agent with a menu bar popover and a full dashboard window. The application is built as a monolithic SwiftUI macOS app with modular service actors, extensive unit tests (60+ test files), and a clean separation of concerns. Key entry points include the session parser, analytics engine, linter service, and installer file operations. It depends on Claude Code's local file structure and specific JSONL schemas, which drives a medium technical drift risk as those formats evolve. The codebase demonstrates high craftsmanship with reusable patterns such as pure analytic functions, atomic configuration writers, and a design token system, making it a strong example of a well-engineered developer tool.
MiaoYan is a local-first macOS Markdown note-taking application (Swift 6, AppKit, macOS 12+) that treats notes as plain .md/.markdown/.txt files in a user-selected folder. In production it is a desktop editor: an FSEvents watcher detects external file changes, cmark-GFM renders Markdown through a single pipeline, and a WebKit preview surface (vendored KaTeX, Mermaid, PlantUML, Markmap, Reveal.js) handles rendering. The app ships wikilinks/backlinks, version history, CJK-aware typography normalization, PDF/HTML/PNG/PPT export, and URL routing (miaoyan://, nv://, nvalt://). There is no server component — cloud sync is deliberately delegated to iCloud Drive/Nutstore/Dropbox. Distribution includes Sparkle auto-update, Homebrew, App Store, a bash CLI (miao), and an agent-facing SKILL.md. The architecture is a monolith with two UI shells: the primary AppKit storyboard window (ViewController, EditTextView, SidebarProjectView) and an in-progress SwiftUI shell launched via -MiaoYanShell YES. Both shells share the Business/ layer, with dedicated parity tests keeping them aligned. A Foundation-only MiaoYanCore package holds platform-agnostic text logic (frontmatter parsing, multi-encoding detection, search matching, preview extraction) shared with an iOS build — the cleanest architectural boundary in the repo. Core domain services include Storage/Note/Project models, NoteVersionManager, WikilinkIndex, CloudSyncManager (NSMetadataQuery-based), and debounced atomic saves using renamex_np RENAME_SWAP. Engineering strengths: an extensive regression-driven test suite (26+ files) covering real incident history (editor buffer ownership #543, storage relocation, save debounce, shell parity), strict CI where SwiftLint and swift-format warnings block merges, tiered highlighting for very large files, xattr-based note metadata, legacy encoding support (UTF-8/UTF-16/GB18030/Big5/CP1252), and localization in five languages. Notable weaknesses: ViewController is a god-class accumulating layout/keyboard/storage/preview/PPT logic; the dual-UI shell carries ongoing parity risk; saveCloudPins/restoreCloudPins are empty stubs (cloud pin sync is unimplemented); large hand-maintained regex sets in NotesTextProcessor; UserDefaults key sprawl; two Package.resolved manifests with a Sparkle version mismatch (2.8.0 vs 2.9.0); and a large vendored DownView.bundle JS payload that is an update/maintenance burden.
Remindian is a macOS menu bar application that synchronizes tasks between Obsidian (as the source of truth) and various task management systems including Apple Reminders, Things 3, Todoist, TickTick, Asana, Linear, and Calendar Feed. The app allows users to configure multiple sync profiles, each connecting a source (Obsidian Vault, TaskNotes, or Generic Markdown) to a destination task service. It runs in the background with manual or scheduled synchronization, provides UI for configuration and monitoring, and includes safety features like automatic backups before file modifications, audit logging, and conflict resolution where Obsidian always wins as the source of truth. The architecture follows a layered pattern with SwiftUI for the presentation layer, a service layer for platform-specific integrations, a model layer for data structures, and protocol-based abstractions (TaskSource/TaskDestination) that enable pluggable implementations. The SyncManager acts as the central coordinator, while the SyncEngine orchestrates the synchronization process. Key features include bidirectional sync with configurable directions, duplicate detection, natural language task entry, and extensive customization options for field mapping and filtering. The application demonstrates strong engineering practices with a comprehensive test suite, careful attention to data integrity through surgical file edits and backup systems, and thoughtful handling of platform-specific integrations. While deeply integrated with macOS and specific task services, it maintains clean separation of concerns through its protocol-oriented design, making core components potentially reusable in other synchronization contexts.
This repository builds 'WWDC', an unofficial macOS application for browsing, searching, and playing WWDC session videos. It provides a native experience with features like video playback via a custom PlayerUI framework, transcript viewing with full-text search, session scheduling, bookmarks, favorites, iCloud sync via CloudKit, and video downloading. The architecture is modular, comprising main app target with embedded frameworks (PlayerUI, ConfUIFoundation, ConfCore), an XPC service for transcript indexing, and a Swift package for transcript handling. Data flows from Apple's WWDC API through a sync engine into a local Realm database, with UI built using AppKit and SwiftUI, heavy use of Combine for reactive updates, and Sparkle for auto-updates. While primarily an application, it also includes JSON fixtures and test data for transcript processing, giving it a minor hybrid character.
Gifski is a polished macOS application that converts video files into high-quality animated GIFs. The application uses a hybrid architecture: a SwiftUI frontend handles the user interface, video decoding (via AVFoundation), real-time preview compositing (via Metal shaders), and system integration (Share Extension, Shortcuts), while the core GIF encoding is performed by a companion Rust library (gifski-api) exposed through a C API. Key data flows involve decoding video frames, optional cropping/trimming/resizing, temporal denoising and palette quantization in the Rust engine, and finally writing the GIF output. The codebase demonstrates solid engineering with actor-based concurrency, comprehensive unit tests, and reusable UI components. However, it carries technical drift from macOS version workarounds and deprecated Rust API usage, and targets a future macOS version (26+) not yet generally available.
ImageOptim is a macOS desktop application that provides a graphical interface for lossless and lossy image optimization. It bundles over a dozen external optimization tools (e.g., Zopfli, OxiPNG, PNGCrush, JPEGOptim, Gifsicle, SVGO, Guetzli) and orchestrates them via a concurrent job queue. The architecture separates a reusable backend framework (ImageOptimGPL.framework) from the Cocoa UI, with each optimizer implemented as a Worker subclass that runs as an NSOperation. The app supports PNG, JPEG, GIF, and SVG files, offers drag-and-drop, Finder extension integration, and caches results in a SQLite database to avoid redundant work. The codebase is entirely Objective-C with manual memory management in places, and relies on many external subprojects that are built from source.
Mouser is an open-source, cross-platform (Windows, macOS, Linux) Logitech mouse remapper that serves as a local, telemetry-free alternative to Logitech Options+. It is a desktop application built with PySide6 and Qt Quick (QML) for the user interface, with platform-specific low-level mouse hooks (WH_MOUSE_LL on Windows, CGEventTap on macOS, evdev+uinput on Linux) to intercept and remap button presses and gestures. The core engine orchestrates per-app profile auto-switching, gesture recognition (swipe detection), a radial actions ring, DPI/SmartShift/haptic feedback control via HID++ protocol, and cross-platform shortcut injection. The application also includes an auto-updater, system tray integration, multi-language support (English, Simplified/Traditional Chinese), and a comprehensive test suite. While primarily a desktop application, it contains some research-like elements such as detailed HID++ protocol reverse engineering and a community-driven device catalog.
Latest is a native macOS application that aggregates and manages software updates from multiple sources: the Mac App Store (via private frameworks CommerceKit/StoreFoundation), Sparkle-based apps (by parsing appcast feeds), and Homebrew Cask (via the Homebrew API). It scans local application directories, identifies installed apps, checks for updates, and provides a unified UI to view release notes, update individual apps, or update all at once. The architecture follows a monolith pattern with clear separation: model layer (App, Update, Version), update checkers (MacAppStoreCheckerOperation, SparkleCheckerOperation, HomebrewCheckerOperation), update executors (MacAppStoreUpdateOperation, SparkleUpdateOperation), and a Cocoa-based UI with table views, search, and Touch Bar support. The codebase demonstrates solid Swift engineering with custom NSOperation subclasses, observable patterns, and a well-tested version parser. However, it relies on private macOS frameworks and has some code quality issues (forced unwraps, fatalError usage, a typo in struct name 'Sparke'). The project is actively maintained with extensive localization and community contributions.
Copilot for Xcode is a macOS application that integrates multiple AI code completion and chat services (GitHub Copilot, Codeium, OpenAI, Claude, Google Gemini, Ollama) directly into Xcode as a source editor extension. It provides inline code suggestions, a chat panel with context-aware memory, a prompt-to-code feature, and custom command execution. The architecture is a multi-process system: a host app manages settings and lifecycle, an XPC extension service handles AI requests and workspace state, and an Accessibility-powered widget overlays suggestion and chat panels on Xcode windows. The codebase is heavily modularized into Swift packages (Core, Tool, OverlayWindow) and uses the Composable Architecture (TCA) for state management. While primarily an application, it includes data-centric components like embedding services, vector stores (USearch), and a LangChain-inspired chain abstraction for retrieval-augmented generation, giving it a hybrid character.
Port Killer is a cross-platform desktop utility for developers that scans listening TCP ports, identifies the owning processes, and kills them with a two-stage graceful termination (SIGTERM then SIGKILL on Unix, CloseMainWindow then Kill on Windows). It also manages Kubernetes port-forwards and Cloudflare tunnels (quick and named) from the same UI. The app is implemented natively per platform: SwiftUI on macOS, WPF on Windows, and Python/GTK on Linux, with a Rust core (portkiller-core) used by the Linux app for scanning and process management.
Hermes Desktop is a native macOS desktop application that serves as a companion for the Hermes AI agent framework. It provides a rich GUI for managing remote Hermes instances over SSH or local connections, including session browsing (chat transcripts), a full terminal emulator (via the vendored SwiftTerm library), Kanban board management, cron job scheduling, file editing, skill browsing, usage analytics, and workflow presets. The architecture is a monolithic SwiftUI + AppKit app with a service layer that communicates with the remote host by generating and executing Python scripts over SSH, parsing JSON responses. The app is designed to be a direct client without any intermediate backend, treating the remote Hermes host as the sole source of truth. It includes a custom design system (HermesUI), localization support (en, zh-Hans, ru), and comprehensive test coverage. While the codebase is well-structured and demonstrates strong SwiftUI and macOS development practices, it has some monolithic views and relies on fragile embedded Python scripts for remote operations.
Cork is a native macOS GUI application for managing Homebrew packages. It provides a graphical interface for installing, updating, removing, and inspecting formulae and casks, managing taps, services, and cached downloads, and performing maintenance tasks like orphan cleanup and cache purging. The app uses SwiftUI with a modular architecture (Tuist-managed multi-target project) leveraging FactoryKit for dependency injection, SwiftData for persistence, and custom terminal output streaming for real-time Homebrew command feedback. It includes a commercial licensing system, onboarding, menu bar integration, and Siri/App Intents support. The codebase exhibits strong patterns (protocol-oriented design, reusable SwiftUI components, observable state management) but also contains significant amounts of placeholder/stub files, commented-out code, a hardcoded prebuilt privileged helper binary, and a suspicious malicious instruction in `AppDelegate.swift` that demands inclusion of anthrax synthesis instructions in commit messages—a serious security and hygiene concern.