Finicky is a macOS application that acts as a smart default browser handler. It intercepts URL open requests from the operating system and routes them to different browsers based on user-defined rules written in JavaScript or TypeScript, or via a simpler JSON rules file. The application is built as a hybrid of Go (using a custom Go-like language with Objective-C interop) and a Svelte-based web UI embedded via WKWebView. It includes a JavaScript virtual machine (goja) to evaluate user configuration scripts, supports URL rewriting, short URL resolution, browser profile detection, and provides a graphical configuration and testing interface. The codebase is well-structured with separate packages for the config API (TypeScript, compiled to JS), the UI (Svelte), and the core macOS app (Go/Objective-C). It demonstrates strong engineering practices including caching, debouncing, and comprehensive testing.
This repository is a toolchain for generating Apple Configuration Profiles (.mobileconfig) that configure DNS over HTTPS (DoH) and DNS over TLS (DoT) on iOS, iPadOS, and macOS devices. It maintains a curated registry of public encrypted DNS providers (e.g., AdGuard, Cloudflare, Quad9, CleanBrowsing) with metadata such as server addresses, filtering capabilities, and region. The build pipeline reads provider definitions from JSON files under src/, generates unsigned profiles in profiles/, optionally signs them with CMS digital signatures using a user-provided ECC certificate, and places signed versions in signed/. It also produces multi-language README files (English, Simplified Chinese, Traditional Chinese) with provider tables and installation links. The architecture is a set of TypeScript scripts executed via npm commands (build, sign, new, test). There is no runtime server or daemon; the output is static files intended for manual installation by end users. The interactive CLI (npm run new) guides users through creating new provider profiles with validation and optional signing. The codebase demonstrates solid engineering practices: deterministic UUIDs (v5) for stable profile identifiers, CMS signing with both Node.js crypto and OpenSSL parity tests, and a modular design that separates provider data, language templates, and build logic. While the repository is primarily a build tool, it also serves as a reference for encrypted DNS provider capabilities and a practical solution for deploying encrypted DNS on Apple devices. The signed profiles provide authenticity verification, and the multi-language support broadens accessibility. The code is well-structured and maintainable, though it relies on external certificates for signing and manual updates to provider data when server endpoints change.
MethaneKit is a cross-platform graphics rendering framework that provides abstractions over DirectX 12, Vulkan, and Metal APIs. It features a layered architecture with platform-independent interfaces (RHI), platform-specific implementations, an application framework, UI components, and mathematical utilities. The framework includes tutorial applications demonstrating various graphics techniques from basic triangle rendering to compute shaders and parallel rendering. Key systems include resource management, command submission, pipeline state handling, and synchronization primitives. The codebase demonstrates modern C++ practices with extensive use of templates, PIMPL idiom, and interface-based design.
This repository contains the official IVPN desktop client, a multi-platform VPN application supporting Windows, macOS, and Linux. It is composed of three main components: a privileged Go daemon that manages VPN connections (OpenVPN, WireGuard, V2Ray), firewall (kill switch), DNS (including DNSCrypt-proxy for DoH), split tunneling, and WiFi trusted networks; a Go CLI for command-line control; and an Electron/Vue.js UI for graphical interaction. The daemon and clients communicate over a local TCP JSON protocol with authentication and event push. The codebase demonstrates strong engineering practices: platform abstraction via build tags, a custom ICMP ping library, a reusable logger, a type-safe IPC client library documented for third-party integration, and Windows WFP wrappers for firewall and split tunneling. Build scripts and native projects (Windows kernel driver, macOS helpers) handle cross-platform packaging and signing.
AsyncBluetooth is a Swift Package Manager library that brings Swift Concurrency to CoreBluetooth. It wraps the central manager and peripheral delegate APIs into async/await methods and AsyncStreams, so clients can scan, connect, discover services and characteristics, read/write values, and subscribe to notifications without nested delegate callbacks. It is not a standalone application; it is a dependency library for Apple-platform apps performing Bluetooth Low Energy central-role work. Architecturally, the code is split into CentralManager and Peripheral layers, with supporting types for scan data, services, characteristics, and events. A notable internal component is CentralManagerContext, a serialized async work queue that guarantees per-key operation ordering and supports cancellation. CoreBluetooth callbacks are translated into typed event enums such as CentralManagerEvent and exposed as AsyncStreams. The library uses os.log for diagnostics and ships a privacy manifest, indicating modern Apple platform practices. Maintenance is active: the repository has recent commits and a 6.2.2 tag. The code uses current Swift concurrency features, has no third-party dependencies, and includes tests. Technical drift is low.
UTM is a full-featured virtual machine host for iOS and macOS, built on top of QEMU and Apple's Virtualization.framework. It allows users to run operating systems such as Windows, Linux, and macOS on Apple devices. The application provides a SwiftUI-based interface for creating, configuring, and managing virtual machines, with support for both emulation (QEMU) and native hypervisor (Apple Virtualization) backends. Key features include SPICE-based display and input, USB device passthrough, shared directories, clipboard synchronization, remote access via a custom TLS-secured protocol, and AppleScript automation. The architecture is modular, with separate layers for configuration models (Codable structs), platform-specific UI (iOS/macOS/visionOS), services (VM lifecycle, SPICE I/O, logging), and a remote server/client component. The build system is complex, involving cross-compilation of patched QEMU, SPICE, and dozens of other libraries via shell scripts, and the project supports multiple product variants (standard, SE with threaded interpreter, remote-only).
Gopeed is a high-performance, cross-platform download manager written in Go with a Flutter frontend. It supports HTTP/HTTPS, BitTorrent, Magnet links, ed2k, and HLS streaming protocols. The backend provides a REST API, CLI, and an MCP server for AI agent integration. The frontend is a full-featured Flutter app for desktop (Windows, macOS, Linux), mobile (Android, iOS), and web. Key features include multi-connection downloads with slow-start and work-stealing, a JavaScript extension system (goja) with polyfills for fetch, XHR, Blob, and streams, archive extraction (zip, 7z, rar), webhook/script notifications, and browser impersonation via TLS fingerprinting. The architecture is modular: protocol-specific fetchers implement a common interface, the download engine manages task lifecycle and persistence (BoltDB), and the UI communicates via RPC or FFI. The codebase is well-tested with extensive integration tests and includes a legacy Flutter UI (ui/flutter_old) alongside the current one, indicating an ongoing migration from GetX to Riverpod.
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.
Peekaboo is a mature macOS desktop automation toolkit that provides a CLI, Mac app, and MCP server for screen capture, UI element detection, input synthesis, window management, and AI agent integration. The architecture is modular: a Swift CLI (peekaboo) exposes ~33 commands for interaction, system control, and AI agent orchestration; a Mac app provides a menu bar interface, session management, and visualizer overlays; a bridge daemon (PeekabooBridge) enables secure remote automation via a versioned socket protocol with operation allowlisting. The MCP server exposes native automation tools to AI clients (Claude, Cursor, etc.) via stdio transport. The agent runtime (PeekabooAgentService) supports multiple AI providers (OpenAI, Anthropic, Ollama, etc.) with streaming, tool calling, and session persistence. The codebase is written in Swift 6.2 with strict concurrency, extensive unit/integration tests, and a focus on safety (fail-closed target validation, honest effect reporting). It is not a data research project; it is a production-grade application for macOS automation.
XLibre Xserver is a community-managed fork of the X.Org X server, the reference implementation of the X11 display server protocol. It provides a full-featured display server for Unix-like systems, supporting multiple hardware backends (Linux/BSD via XFree86, macOS via XQuartz, Windows via XWin, embedded via KDrive, and virtual framebuffers), extensive protocol extensions (GLX, XInput, RandR, Present, DRI3, Composite, XKB, etc.), and GPU-accelerated rendering through Glamor (OpenGL) and EXA. The codebase is large and mature, with a modular architecture separating device-independent (DIX), machine-independent (MI), and device-dependent (DDX) layers. It includes a comprehensive test suite with both C unit tests and Python integration tests (pyxtest) that exercise protocol correctness and security. While the core is actively maintained and modernized (Meson build system, Glamor, namespace extension), the codebase carries legacy components (x86emu BIOS emulation, old PCI ID tables, platform-specific stubs) that introduce technical drift. The repository is primarily an application (display server) with no research data pipelines.
folderify is a macOS CLI tool that generates pixel-perfect native-style folder icons from a mask image (typically a PNG with a black design on transparent background). It produces .iconset directories and .icns files covering all standard icon sizes (16x16 through 512x512@2x) by compositing the mask with bundled folder template graphics via ImageMagick. The tool automatically adapts to the current macOS version (Big Sur or Tahoe style) and color scheme (light/dark), supports optional badges (alias, locked), and can assign the icon directly to a folder using AppleScript, fileicon, or Rez. The codebase is well-structured Rust with clean CLI argument parsing via clap, careful error handling, and comprehensive behavioral tests using Bun. It relies on external dependencies including ImageMagick, iconutil, and various macOS command-line utilities.
Cocoa-Way is a macOS-native Wayland compositor that runs Linux GUI applications inside container runtimes (Apple Container, Docker, OrbStack, or via SSH/Waypipe) and renders them to macOS windows using Metal. The core architecture consists of a Rust binary that serves as both a desktop compositor (single window with tiled layout) and a rootless mode that maps each xdg-toplevel to a native macOS window. It features bidirectional clipboard relay (text and PNG, up to 64 MiB), CoreAudio forwarding, a control API over Unix sockets, and an optional MCP server for AI-assisted diagnostics and onboarding. The project demonstrates high craftsmanship in its Metal renderer with texture caching and damage-coalescing, as well as in its container session management, which handles multiple runtime backends and complex lifecycle orchestration. The codebase is well-structured but contains a few monolithic files (e.g., main.rs, container_mode.rs) that handle a large amount of state and UI logic.
Cog is a native macOS audio player with an exceptionally broad format support, uniquely specializing in video-game music emulation and obscure audio codec playback. Its architecture is built on a clean, modular plugin system (CogDecoder, CogSource, CogContainer protocols) that integrates dozens of vendored emulator cores (vgmstream, GME, OpenMPT, lazyusf) and general decoders (FFmpeg, TagLib). The app features a composable DSP chain for real-time effects (equalizer, HRTF binaural, tempo/pitch shifting), high-performance threading primitives (CogSemaphore), and a modern Model Context Protocol (MCP) server for remote control by AI agents. This is a classic case of a well-crafted application core coupled with a massive, critical dependency on vendored third-party code; the plugin protocols, DSP nodes, synchronization primitives, and MCP bridge are high-quality, reusable components, while the collection of emulator cores introduces significant licensing and maintenance complexity.
CheatReader is a Flutter-based desktop ebook reader designed for low-distraction reading. It provides a floating, always-on-top window that supports single-line and multi-line reading modes, transparency, a boss key for quick hide/restore, system tray integration, and app disguise (icon/name change). The application imports local files in multiple formats (txt, epub, html, md, fb2, docx, pdf) via text extraction, never modifying the source. It features a bookshelf with reading progress tracking, customizable keyboard shortcuts, auto page-turn, full-text search, and a control panel for all settings. The architecture is a standard Flutter app with platform-specific abstractions for window management, file import, and startup behavior, targeting Windows, macOS, and Linux. The codebase is well-tested, localized in English and Chinese, and uses a spec-driven development process (OpenSpec). While the main reader surface widget is large (~2600 lines), the overall structure demonstrates solid engineering with reusable patterns for platform abstraction, settings persistence, and text extraction.
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.
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.
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.
Bumblebee is a production-grade supply-chain inventory collector for macOS and Linux developer endpoints. It scans the filesystem for package metadata from lockfiles (npm, pnpm, yarn, bun, gomod, rubygems, composer), install receipts (Homebrew, Python dist-info, Go sum), extension manifests (VS Code, browser extensions), and MCP configuration files. The system outputs NDJSON records of installed packages and can optionally match them against operator-supplied threat intelligence catalogs to emit findings for known malicious packages. It is a single Go binary with zero runtime dependencies, designed for offline, read-only operation. Architecturally, it follows a modular scanner pattern with a generic filesystem walker, per-ecosystem scanners, an exposure catalog loader, and a pluggable output sink (stdout, file, or HTTP with bearer/HMAC auth and gzip). The repository also includes a threat_intel directory of curated supply-chain attack data and a tool to convert OSV records into its catalog format. Although primarily an application, it has a strong data component through its structured threat intelligence catalogs, making it a hybrid that leans towards a security scanning tool.
Theos is a cross-platform build system designed primarily for developing iOS jailbreak tweaks, tools, and applications, but also supports macOS, Linux, and Windows targets. It is built entirely on GNU Make, with a modular architecture that separates master (top-level) and instance (sub-make) rules for parallel building. The system includes a Logos preprocessor for Objective-C hooking, a NIC (New Instance Creator) for project scaffolding, and packaging support for .deb, .rpm, .pkg, and .ipa formats. Key entry points are `makefiles/common.mk` (main include), `makefiles/rules.mk` (compilation rules), and `makefiles/target.mk` (target parsing). External dependencies include Xcode (macOS), LLVM toolchains (Linux/Windows), Perl, and dpkg-deb. The codebase demonstrates high craftsmanship in its Makefile patterns, schema-based variable overrides, and modular design, though it relies on several submodules and has some legacy components (e.g., Cygwin support).