objc2 is a Rust library that provides safe, idiomatic bindings to Apple's Objective-C runtime and a vast portion of its system frameworks (Foundation, AppKit, Metal, CoreFoundation, and hundreds more). The core crate wraps the Objective-C runtime with type-safe message sending, class definition, reference counting via Retained<T>, and protocol support. Around it, the workspace includes supporting crates for Objective-C blocks (block2), Grand Central Dispatch (dispatch2), a header translator that auto-generates Rust code from Apple's SDK headers, and a documentation parser (apple-doc). The architecture is a large Rust workspace (hundreds of crates) with a clear separation: a lightweight runtime layer (objc2-encode, objc2-exception-helper, objc2-proc-macros), the main objc2 crate with macros and runtime types, and generated framework crates that follow a uniform pattern (extern_class!, extern_methods!, etc.). The project places heavy emphasis on safety and correctness, employing compile-time encoding verification, fuzz testing, assembly-level baseline tests for optimized message sending, and UI tests to catch type errors at compile time. Despite its complexity, the code exhibits strong craftsmanship: the macro infrastructure is well-organized, memory management is carefully designed (two-phase initialization, drop flags, Writeback helpers), and performance-critical paths use inline assembly for retain/autorelease optimization. The project is actively maintained with a modern toolchain, CI against multiple runtimes (Apple, GNUstep, ObjFW), and thorough documentation. It stands as the most comprehensive Rust-to-Objective-C bridge available, suitable for building native macOS/iOS applications entirely in Rust.
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.
Pake is a CLI tool that packages any webpage or local web build into a lightweight native desktop application (~5MB) using Tauri (Rust) and the system WebView. It supports macOS, Windows, and Linux, producing installers in dmg/app, msi, deb/AppImage/rpm/zst formats. The architecture is a dual-language system: a TypeScript CLI (Commander.js) orchestrates the build process, generating Tauri configuration files, handling icon conversion, and managing platform-specific builders (MacBuilder, WinBuilder, LinuxBuilder) via a base builder pattern. The Rust Tauri runtime provides the desktop shell with webview injection scripts for features like find-in-page, fullscreen polyfill, style injection, clipboard bridging, and auth/popup routing. The project includes extensive unit and integration tests, a GitHub Action for CI/CD, and machine-readable JSON output for agent integration. It is not a data or research project; it is a pure application packaging tool.
IINA is a modern macOS media player built on the mpv framework. It provides a native macOS interface for playing local and online media, with features including subtitle support, playlist management, Touch Bar integration, picture-in-picture mode, and a JavaScript-based plugin system for extensibility. The application follows a modular architecture separating playback core (PlayerCore), UI components, preference management, plugin system, and utilities. Key strengths include a well-crafted threading system (Atomic/ReadWriteAtomic property wrappers), structured logging, and a preference observation pattern. While the core PlayerCore class exhibits some complexity, the overall codebase demonstrates professional macOS development practices with clean abstractions in utility modules and extensibility points.
OpenSCAD is a mature, script-based 3D CAD modeler. It provides a declarative language for defining solid geometry through Constructive Solid Geometry (CSG) operations, extrusions, and transformations. The application consists of a C++ core that parses the custom scripting language, builds an AST, and evaluates geometry using either the CGAL or Manifold library for boolean operations. Rendering is handled via OpenGL with both preview (OpenCSG) and final render modes. The GUI, built on Qt, includes a code editor with syntax highlighting, a 3D viewport, parameter customizer, and an integrated AI assistant for code generation. Exports to STL, OBJ, SVG, 3MF, PDF, and other formats. The codebase demonstrates strong engineering with clear module separation (core, geometry, glview, gui, io, utils), extensive regression tests, and reusable patterns such as visitors, builders, and self-contained geometry utilities.
DashBeam is a peer-to-peer encrypted file transfer application that operates without a central server. Built on the Iroh networking stack (QUIC, BLAKE3, relays), it enables direct device-to-device transfers with end-to-end encryption, NAT traversal via relays, and local LAN discovery via mDNS. The application is cross-platform, targeting desktop (Windows, macOS, Linux via Tauri), Android, and web (via a Rust WASM bridge). Its architecture cleanly separates a core protocol crate (P2P wire format, pairing, identity) from platform-specific I/O crates (native disk I/O for desktop/mobile, in-memory for web), all wrapped by a unified engine facade. The frontend is a modern React/TypeScript SPA with Zustand state management, a comprehensive UI component library built on Base UI, and 20+ locale translations. The system supports one-time share tickets, permanent device pairing, broadcast mode, transfer progress with resume, and self-hosted infrastructure. No telemetry or accounts are required, and the AGPL-3.0 license ensures openness.
SwiftGen is a mature, production-grade Swift code generation tool that produces type-safe Swift (and Objective-C) code from project resource files. It parses asset catalogs, strings files, fonts, storyboards, JSON, YAML, plist, Core Data models, colors, and arbitrary files, then feeds the parsed context into Stencil templates to generate compile-time safe accessors. The tool is primarily a CLI executable (`swiftgen`) that can be integrated into Xcode build phases, but it also exposes a reusable framework (`SwiftGenKit`) for parsing and context generation. The architecture cleanly separates parsing (SwiftGenKit) from template rendering (Stencil) and CLI orchestration (SwiftGenCLI), with a YAML configuration file (`swiftgen.yml`) centralizing all inputs, outputs, and parameters. The codebase is well-tested with unit tests for each parser and template output comparison against extensive fixture files. It supports Swift 4 and 5 output variants, custom templates, and parameters like `publicAccess`, `bundle`, and `lookupFunction`. While the project has some deprecated features and a large fixture set, it is actively maintained with recent commits, a clear migration guide, and a robust release pipeline via GitHub Actions.
Xcodes is a command-line tool for installing, managing, and switching between multiple versions of Apple's Xcode IDE. It provides subcommands for downloading, listing, selecting, uninstalling, and updating Xcode releases, as well as managing simulator runtimes. The tool supports two data sources: scraping Apple's Developer downloads page (the 'apple' source) and consuming the unofficial Xcode Releases JSON feed ('xcodeReleases'). Authentication is handled through Apple ID with two-factor or SMS fallback, or via fastlane session cookies. The architecture is a modular Swift Package Manager project with a thin CLI entry point (using Apple's ArgumentParser) and a core library (XcodesKit) that encapsulates all business logic. The core library uses a lightweight dependency injection pattern via an Environment struct, a strategy pattern for downloads (URLSession or aria2), and a service-oriented design for runtime installation, list management, and system configuration. The codebase exhibits strong Swift concurrency adoption and includes test fixtures for parsing Apple HTML and property-list data. While the Apple scraping approach is inherently fragile, the overall architecture is well-structured, testable, and follows modern Swift best practices.
This repository is a comprehensive native UI component library that implements Microsoft's Fluent Design System for Apple platforms (iOS, macOS, and visionOS). It provides over 30 reusable controls—such as buttons, avatars, tables, navigation bars, date pickers, tooltips, and notifications—each backed by a sophisticated token-based theming system. The architecture is modular: a common core (`FluentUI_common`) defines design tokens, themes, and utilities, while platform-specific modules (`FluentUI_iOS`, `FluentUI_macOS`) contain UIKit and AppKit implementations. Both SwiftUI and UIKit are supported, with bridging components like `ControlHostingView` and `MSF*` wrapper classes. The library is distributed via CocoaPods and Swift Package Manager, and includes extensive demo apps and UI tests. The codebase is actively maintained, with CI pipelines, localization automation, and regular commits. The standout feature is the token system (`ControlTokenSet`, `TokenSet`, `DynamicColor`), which provides a clean, extensible abstraction for theming that could be extracted and reused in other projects.
Swarm is a production-grade Swift-native agent runtime framework for building multi-agent conversational systems with type-safe tools, on-device Apple Foundation Models, composable workflows, memory, guardrails, and observability. The architecture is modular: core agent execution (Agent, Workflow, Job) with pluggable inference providers (Foundation Models, OpenAI-compatible, mock), memory backends (conversation, sliding window, summary, vector, persistent via SwiftData or Wax SQLite), and tool integration (built-in tools, MCP protocol, web search). Key entry points include Agent.run()/stream(), Workflow.execute(), and the SwarmMCPServerService for exposing tools via MCP. Data flows involve agent turns with tool calls, memory retrieval/consolidation, and durable workflow checkpointing via the HiveCore deterministic runtime. External dependencies include Apple FoundationModels (macOS 26+), swift-log, swift-syntax (for macros), and optional Wax (SQLite vector store) and OpenTelemetry SDK. The framework emphasizes compile-time safety via @Tool and @Agent macros, and provides resilience patterns (retry, fallback, circuit breaker, rate limiting) and observability (tracing, metrics, OpenTelemetry).
remindctl is a macOS command-line interface for Apple Reminders, built with Swift and Apple's EventKit framework. It provides a comprehensive set of commands to create, edit, complete, delete, and search reminders, manage lists, set due dates, alarms, recurrence, location triggers, and URLs. The application is structured as a modular library (RemindCore) containing the core EventKit interaction and business logic, and a CLI executable (remindctl) that uses the Commander library for command routing and argument parsing. The CLI supports multiple output formats (JSON, plain, table, quiet) and includes advanced features like fuzzy list name resolution, stable numeric indexing across reordered fetches, and a custom async timeout pattern for system operations. The codebase demonstrates strong Swift concurrency practices (async/await, actors), comprehensive unit tests, and a well-documented release pipeline with signed notarized binaries and Homebrew distribution.
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.
ImHex is a cross-platform hex editor and binary analysis tool designed for reverse engineers, programmers, and digital forensics. It provides a rich GUI built on Dear ImGui and GLFW, with a modular plugin architecture that allows extending functionality through dynamically loaded plugins. The core library (libimhex) implements a provider abstraction for various data sources (files, disks, process memory, GDB, SSH, UDP, etc.), an event-driven communication system, a content registry for registering views, tools, settings, and data inspectors, and a pattern language engine for declarative binary parsing. The application includes built-in plugins for hex editing, data inspection, disassembly (Capstone), diffing, YARA rule matching, hashing, decompression, visualizations (3D, plots, images), scripting (C and .NET), and a Model Context Protocol (MCP) server for AI-assisted analysis. It supports undo/redo, bookmarks, patches, projects, themes, layouts, achievements, tutorials, and a command palette. The codebase is well-structured with clear separation between core library, plugins, and platform-specific code, though some components are tightly coupled to ImGui internals and the custom pattern language.
Stats is a native macOS menu bar system monitor that provides real-time hardware and software metrics for CPU, GPU, RAM, Disk, Network, Battery, Sensors (temperature/voltage/fan), Bluetooth, and Clock. Built entirely in Swift with AppKit, it uses private IOKit, SMC, and IOReport APIs to collect system data, and offers highly customizable widgets (mini, line/bar/pie charts, tachometer, text, etc.) drawn directly in the menu bar. The architecture is modular: each monitored subsystem lives in its own 'Module' directory with a consistent structure (main.swift, readers, popup, settings, notifications, portal). A shared 'Kit' framework provides reusable components including a reader base class with interval management and history persistence via bundled LevelDB, a thread-safe key-value store wrapper, and a set of custom drawing chart widgets. The app also supports remote monitoring via an optional cloud service (System Stats), privileged helper for fan control, macOS widget extensions, and extensive localization (40+ languages). The codebase demonstrates strong engineering practices with clean abstractions, encapsulation, and reusability, though some modules exhibit boilerplate duplication and the project relies on several deprecated or private APIs that may require updates for future macOS releases.
btop++ is a cross-platform system resource monitor implemented in modern C++ (C++20/23). It provides a real-time terminal user interface displaying CPU, memory, disk, network, process, and GPU utilization. The architecture is modular: a main thread handles input and rendering while a runner thread periodically collects system metrics via platform-specific collectors (Linux: /proc, /sys, perf_event_open; macOS: sysctl, SMC, IOReport; BSD: kvm, sysctl). The codebase features a theming engine with gradient support, a config system with TOML-based persistence, and bundled fmt library for type-safe formatting. While the project demonstrates solid engineering with RAII patterns, atomic locks, and terminal escape code abstractions, it relies heavily on global state and platform-specific ifdefs, which limits testability and portability. GPU monitoring supports NVIDIA, AMD, and Intel integrated GPUs through dynamic library loading and kernel interfaces.
Kazumi is a cross-platform Flutter application for browsing, collecting, and streaming anime (番剧). At its core, it provides a curated media experience: users can discover anime via popularity rankings, weekly schedules, text and image (trace.moe) search; manage a local watchlist synced with Bangumi (bgm.tv) and WebDAV; and play videos using a hardware-accelerated media_kit (libmpv) player with danmaku overlay, Anime4K super-resolution shaders, Picture-in-Picture, and external player support. It also downloads episodes (HLS segments) for offline playback and supports synchronized group viewing via the Syncplay protocol. The application is built as a Flutter monolith with modular routing (flutter_modular), reactive state management (MobX), local storage (Hive), and a custom plugin system that defines scraping rules (XPath/API) to extract video sources from third-party websites. External dependencies include Bangumi, DanDanPlay, trace.moe, WebDAV servers, and a GitHub-hosted plugin catalog. The codebase demonstrates mature engineering practices including well-isolated async utilities, event-sourced history sync with conflict resolution, and platform-specific WebView integrations for video source extraction and captcha handling.
shadPS4 is a PlayStation 4 emulator for Windows, Linux, and macOS, written in C++20. It emulates the PS4's AMD GCN GPU via a custom shader recompiler that translates GCN instructions to SPIR-V, and implements high-level emulation (HLE) of PS4 system libraries (kernel, libc, networking, audio, video, input, etc.). The architecture is monolithic with modular subsystems: a Vulkan renderer with texture/buffer caches, a shader recompiler with IR optimization passes, a file system abstraction supporting host files and ZArchive, and an ImGui-based debug UI. While many library functions are stubbed or partially implemented, the core GPU and CPU emulation is functional enough to run several commercial games. The codebase demonstrates strong engineering practices with reusable common utilities (bitfields, slot containers, thread-safe queues) and a well-structured shader compilation pipeline. It is a hybrid project, combining software application development with significant reverse-engineering and data analysis of PS4 firmware and GPU architecture.
FluidVoice is a macOS desktop application for real-time voice dictation, meeting transcription, and AI-powered text enhancement. It provides a local-first dictation experience with on-device speech recognition (Parakeet, Nemotron, Whisper, Apple Speech) and optional cloud AI post-processing. The application features a command mode for AI chat, meeting recording with speaker diarization and acoustic echo cancellation, and a local HTTP API for external integrations. The architecture is a native SwiftUI/AppKit application with a service-oriented design. Audio capture uses CoreAudio and ScreenCaptureKit, with a vendored WebRTC audio processing stack for echo cancellation (AEC3), noise suppression, and voice activity detection. Speech recognition is handled by multiple providers, with model downloads from Hugging Face. The application includes a durable PCM storage system with chunk ledger for meeting audio, a signed model release feed for secure updates, and a comprehensive settings/persistence layer using SQLite and UserDefaults. Key entry points include FluidApp.swift (main application), LocalAPIRouter.swift (HTTP API server), MeetingSummaryProvider.swift (AI meeting summaries), ASRService.swift (speech recognition orchestration), and DictationAppSession.swift (dictation workflow). External dependencies include macOS system APIs, SQLite, vendored WebRTC audio processing, and various AI provider APIs (OpenAI, Anthropic, etc.). The repository also contains research-grade audio processing code (WebRTC AEC3, AGC2, RNN VAD) and pronunciation learning evaluation tools, but the dominant character is a production macOS application with extensive testing and CI/CD.
Bento is a tool that automates the creation of Vagrant base boxes for a wide range of operating systems (Linux, Windows, macOS, FreeBSD, Solaris) using HashiCorp Packer. It provides a Ruby CLI (`bento`) that wraps Packer builds, manages metadata, runs Test Kitchen validation, and uploads boxes to Vagrant Cloud. The repository contains parameterized Packer HCL templates, OS-specific variable files, provisioner scripts (shell and PowerShell), and Windows unattended answer files. The architecture is a CLI orchestrator that delegates to external tools (Packer, Vagrant, VirtualBox, VMware, etc.) with a focus on reproducibility and multi-provider support. Although it originated from the Chef ecosystem, it is a standalone infrastructure tool used to produce the official 'bento' Vagrant boxes.
Radix is a native macOS disk space analysis application built with SwiftUI, Swift concurrency, and deep integration with macOS filesystem APIs (APFS clones, FSEvents, getattrlistbulk). The core scanning engine uses actor-based parallelism with atomic directory summarization, incremental rescanning via FSEvent history, and cancellation-aware sort and layout operations. The app features interactive sunburst and treemap visualizations with viewport pan/zoom, a searchable file browser with sorted tables, discard pile for staged trash operations, cross-snapshot comparison showing file changes over time, and export/import of scan snapshots in a versioned compressed archive format (.radixscan). Architecture follows a clean separation of Models, Services, ViewModels, and Features, with heavy use of dependency injection closures for testability. The codebase includes extensive unit, integration, and benchmark tests (Swift Testing) covering correctness, performance, and concurrency safety. It demonstrates high craftsmanship in file tree storage (compact arena with logical scopes), cancellation patterns, APFS storage accounting, and interactive chart geometry.