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.
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.
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.
DeaDBeeF is a cross-platform desktop music player with a modular plugin architecture. It supports a vast array of audio formats including MP3, AAC, FLAC, Ogg Vorbis, Opus, WavPack, Musepack, DTS, and numerous chiptune and video game music formats (SID, NSF, VGM, MOD, S3M, XM, IT, PSF, etc.) through bundled emulation libraries. The core player handles playlist management, metadata caching, replaygain, DSP chain processing, and streaming. Two native GUI implementations exist: a GTK2/GTK3 interface for Linux and a Cocoa interface for macOS, both offering full-featured playback controls, media library browsing, cover art display, and visualization (scope, spectrum analyzer). The player also includes a converter plugin, MPRIS integration, and extensive keyboard shortcut customization. The architecture is centered around a lightweight plugin API (DB_plugin_t) that decouples decoders, outputs, DSP effects, and UI components. The core library (libdeadbeef) provides threading, file I/O, configuration, and message passing. Plugins are loaded dynamically and register themselves via a factory pattern. The media library plugin uses SQLite for indexing and file system watchers (inotify on Linux) for automatic updates. Artwork is fetched from embedded tags and online services (Last.fm, MusicBrainz) with a local cache. The build system uses autotools, premake5, and Xcode projects, with Docker-based CI for Linux, macOS, and Windows. Key data flows include: file opening via VFS abstraction → decoder plugin → decoded audio blocks (ring buffer) → DSP chain → output plugin. Metadata flows from file tags through a caching layer to the UI and media library. The player supports CUE sheets, gapless playback, and crossfading. External dependencies include GTK2/GTK3, libcurl, libsamplerate, and various codec libraries (libmpg123, libmad, libvorbis, libFLAC, etc.), many of which are bundled as source for portability.
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.
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.
MacosUseSDK is a Swift library and collection of command-line tools for macOS accessibility automation. It enables traversing application accessibility trees to inspect UI elements, simulating user input (mouse/keyboard), opening applications, and providing visual feedback for debugging. The architecture centers around a core library with specialized modules for traversal, input simulation, visual feedback, and action orchestration, with six CLI tools exposing different subsets of functionality. Primary use cases include UI testing, accessibility verification, and automated interaction with macOS applications.
Vienna is a mature, macOS-native RSS/Atom/JSON feed reader that operates as a traditional desktop application. In production, it periodically fetches subscribed feeds via HTTP, parses them into structured articles (RSS, Atom, JSON Feed), stores articles and folder metadata in a local SQLite database (via FMDB), and presents them through a Cocoa/AppKit interface with a folder tree, article list, and built-in WebKit-based browser for reading. It supports smart folders, OPML import/export, and synchronization with Open Reader-compatible services (BazQux, FeedHQ, InoReader, TheOldReader). The application also provides a plugin system for extending feed sources, sharing, search, and actions, and uses Sparkle for automatic updates. The architecture follows a classic MVC pattern with a heavy reliance on notifications and the singleton pattern for the database and preferences. Key entry points include `AppController` (application delegate), `ArticleController` (article list management), `FoldersTree` (folder outline), `RefreshManager` (feed fetching), and `Database` (persistence). External dependencies include FMDB, MMTabBarView, TRVSURLSessionOperation, and Sparkle, all managed via Swift Package Manager or manual vendoring. The codebase is a mix of Objective-C and Swift, with some deprecated API usage and private WebKit hooks, but is actively maintained with a comprehensive test suite and CI pipeline.
SparkleShare is a cross-platform desktop file synchronization application that uses Git as its backend, similar to a self-hosted Dropbox. It provides a system-tray-based GUI for Linux (GTK+), macOS (Cocoa), and Windows (WPF), allowing users to sync folders with remote Git repositories via SSH. The application supports encryption (AES-256-CBC), Git LFS for large files, and real-time sync signals via a centralized announcement service. The core sync logic is implemented in the shared 'Sparkles' library, with platform-specific controllers and UIs. The codebase is written in C# using Mono/Xamarin and targets .NET 4.5. The project has been in maintenance mode since its last release in November 2020, with the author seeking sponsors. The architecture is a monolith with a shared core and platform-specific frontends, but the technology stack is aging (GTK+2, WebKit, jQuery 1.6.1) and the build system is fragmented (meson + legacy .csproj). There is minimal test coverage and several abandoned features (e.g., listener layer). Despite these issues, the core sync engine and SSH abstraction demonstrate reasonable engineering for its era.