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.
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.
Mac Messages MCP is a Python application that provides an MCP (Model Context Protocol) server for interacting with macOS Messages. It enables AI assistants like Claude Desktop, Cursor, and others to read, search, and send messages through the native Messages app using standard input/output communication. The application directly accesses the macOS Messages and AddressBook SQLite databases, uses AppleScript for sending messages with automatic SMS/RCS fallback, and provides tools for message retrieval, contact search, fuzzy message search, attachment handling, and permission diagnostics. The architecture follows a clean separation of concerns with the MCP server handling protocol communication, and the messages module containing all core business logic for interacting with macOS systems.
Pear Desktop is an Electron-based desktop application that wraps YouTube Music into a native-like experience with an extensive plugin system. It provides a custom UI built with SolidJS and Material Design 3 (via patched @mdui), system tray integration, media controls, and cross-platform support (Windows, macOS, Linux). The application enhances YouTube Music with over 50 plugins covering audio effects (equalizer, crossfade, compressor), visual customization (album color theme, ambient mode, transparent player), social integrations (Discord Rich Presence, Last.fm scrobbling, collaborative listening via Music Together), and utilities (downloader, synced lyrics, API server, sponsorblock). The architecture follows a clear separation of concerns: main process (Electron), renderer process (SolidJS), and a plugin lifecycle with backend, renderer, and menu contexts. Plugins are loaded dynamically via custom Vite virtual modules and communicate through IPC. The codebase demonstrates strong engineering practices with TypeScript, strict linting, automated CI/CD, and internationalization across 70+ languages. While heavily coupled to YouTube Music's internal APIs and DOM structure, the plugin system and utility abstractions (e.g., createPlugin, VolumeFader, ScrobblerBase) are well-designed and potentially reusable in other Electron music player projects.
Clash Verge Rev is a cross-platform desktop proxy management GUI built with Tauri 2 (Rust backend) and React 19 (TypeScript frontend). It serves as the control interface for the mihomo (Clash Meta) proxy core, enabling users to manage proxy subscriptions, switch proxy groups, toggle system proxy and TUN mode, view real-time traffic and connection details, and configure advanced settings like DNS overrides, script enhancements, and backup to WebDAV. The architecture is modular: a Rust backend handles core lifecycle, config management (using a unique 'Draft' transactional pattern), system integration (tray, hotkeys, auto-launch), and IPC with a privileged service on Windows. The frontend uses MUI, SWR, and virtual lists for a responsive UI with drag-and-drop profile/group editing, a built-in Monaco editor for YAML/JS configs, and real-time WebSocket-based data visualization. The repository also includes a Rust workspace with several crates (media unlock checker, i18n, logging, signal handling, rate limiter, system info plugin) that could be extracted and reused in other Tauri applications.
m-cli is a macOS command-line utility that provides a unified interface for managing system settings, preferences, and services. It consists of a main dispatcher script (`m`) and over 40 plugin scripts, each handling a specific macOS subsystem (e.g., Wi-Fi, Bluetooth, display, dock, permissions). The architecture is a simple plugin-based monolith: the main script resolves the plugin path and delegates execution. Plugins follow a consistent pattern with `--help` output that is parsed by shell completion scripts to dynamically generate completions for bash, zsh, and fish. The codebase is entirely written in Bash (with one Python plugin for screen lock) and relies on macOS native commands (`defaults`, `osascript`, `systemsetup`, `diskutil`, etc.). It is well-structured, with clear separation of concerns, standardized option parsing, and a small test suite using Bats. While the plugins are tightly coupled to macOS, the overall architecture and the dynamic completion generation pattern are reusable concepts.
MarkText is a cross-platform desktop markdown editor (Electron + Vue 3) powered by the Muya WYSIWYG engine. It provides real-time rendering of CommonMark, GFM, and extended syntax including KaTeX math, mermaid/plantuml diagrams, footnotes, tables, task lists, and 30+ themes. The monorepo contains four packages: `desktop` (Electron shell with IPC, preferences, spellcheck, export), `muya` (TypeScript core editor with block-based state, snabbdom rendering, undo/redo via ot-json1, clipboard, and floating UI components), `muyajs` (legacy JavaScript engine, still present for partial feature parity), and `website` (Next.js documentation site). The architecture follows a block tree pattern where each block type (paragraph, heading, list, table, etc.) is a subclass with consistent parent/content interfaces. Communication between the Electron main and renderer processes uses typed IPC channels. The codebase demonstrates strong software engineering practices with extensive unit and e2e test coverage (Playwright, Vitest), reproducible builds (pnpm monorepo), and a focus on regression testing for edge cases. However, the ongoing migration from the legacy `muyajs` engine to the new `muya` engine introduces some code duplication and technical drift, and some modules retain prototype-style JavaScript alongside modern TypeScript classes.
This repository is a curated, community-maintained catalog (awesome list) of high-quality macOS applications and tools, organized by categories such as developer tools, design, AI tools, utilities, and more. It is primarily a multilingual markdown document (English, Chinese, Korean, Japanese) with extensive metadata per entry (name, description, link, badges for open source, freeware, etc.). The repo also includes automated build scripts that parse the markdown into structured JSON (via `build/ast.mjs`) and generate RSS feeds tracking recent additions (via `build/feed.mjs`). The output is published as an npm package (`awesome-mac`), a Docker static site, and GitHub Pages. While not a traditional data research or software application, it functions as a living data catalog with programmatic consumption interfaces. The build pipeline and multilingual synchronization patterns are notable for reuse in other curation projects.
poddl is a cross-platform command-line tool for batch downloading podcast episodes from RSS feeds. It fetches the RSS XML via libcurl, parses it using regex to extract episode titles, URLs, and publication dates, then downloads media files to a specified output directory. The tool supports a variety of options including downloading individual episodes, ranges, newest-first ordering, filename formatting with episode numbers and dates, whitespace handling, and early termination on existing files. The codebase is a monolithic C++11 application split into several classes: Client (HTTP), Parser (RSS parsing), Helper (utilities), FileSystem (cross-platform file operations), and a standalone HtmlCoder for decoding HTML entities. The architecture is clean and modular, with clear separation of concerns, though the use of regex for XML parsing is a known fragility. The repository includes precompiled binaries for Windows and Linux, and the build requires only g++ and libcurl. It is a straightforward, well-structured utility with no external runtime dependencies beyond libcurl.
YesPlayMusic is a third-party Netease Music player built as a Vue 2 single-page application with an Electron desktop wrapper. It provides a full-featured music playback experience including personal FM, daily recommendations, playlists, albums, artists, MVs, and synchronized lyrics. The application integrates with the Netease Music API for all content, supports UnblockNeteaseMusic for alternative audio sources, and offers Last.fm scrobbling, Discord Rich Presence, MPRIS (Linux), Touch Bar (macOS), and global shortcuts. The architecture follows a Vuex store pattern with a singleton Player class proxied into the state, and uses IndexedDB (Dexie) for caching track sources, lyrics, and album data. The Electron main process handles IPC for tray, menu, touchbar, and system integration, while the renderer process runs the Vue app with lazy-loaded routes and i18n support for multiple languages. The codebase is well-structured with reusable UI components (Cover, TrackList, ContextMenu, Modal, SvgIcon) and utility modules (lyrics parser, auth helpers, request interceptor). However, it relies on aging dependencies (Vue 2, Electron 13, Node 14/16) and is in maintenance mode per the README, with a new 2.0 alpha in development. Security concerns include disabled TLS verification in Docker and Electron webSecurity disabled. Despite these issues, the project demonstrates solid engineering practices for a feature-rich music player and offers several components that could be extracted for other Vue projects.
This repository is an 'awesome list' of open-source macOS applications. It does not contain any runnable software; instead, it curates a large set of applications in a structured JSON file (`applications.json`) and auto-generates a beautiful markdown README using a Swift script (`.github/main.swift`). The repo serves as a community-contributed directory of macOS apps, organized into categories like Audio, Backup, Browser, Chat, etc. The core value is the human-curated data in `applications.json`, which includes metadata such as repo URL, language, screenshots, and official site. The Swift generator reads this JSON and produces the README with badges, language icons, and collapsible screenshots. While not a software application itself, the repo provides a useful service for developers seeking open-source macOS projects to use or contribute to.
YapAnimator is a physics-based animation library for iOS, tvOS, and macOS, written in Swift 3.1. It provides a generic `YapAnimator<T>` class that animates any value conforming to the `Animatable` protocol by decomposing it into an array of doubles and applying spring physics integration with a fixed 1/240s timestep. The library includes a convenience layer (`YapAnimatedLayer`) attached to `CALayer` via associated objects, enabling one-liner animations of layer properties like position, bounds, opacity, transform, etc. The core engine runs on a display link (CADisplayLink on iOS/tvOS, CVDisplayLink on macOS) and manages all active animators. The repository is explicitly archived and no longer maintained, with Swift 3.0/3.1 dependencies and no updates since 2017.
BetterDisplay is a macOS application for advanced display management, including HiDPI scaling, brightness/color control, XDR/HDR brightness upscaling, virtual screens, picture-in-picture, DDC and HDMI-CEC control, and custom 3D LUTs. The repository contains only a README and Git internals; no source code is provided for analysis. The README describes a feature-rich commercial application with a Pro license model. The codebase itself is not accessible, so the quality score is based solely on the project's popularity and the completeness of the README documentation. The last commit date is listed as 2026-10-06, which is anomalous and may indicate a data error, but the project appears actively maintained with frequent releases and community engagement.