DeepTide is a cross-platform terminal AI coding agent. The Rust workspace (deeptide-core, deeptide-host, deeptide-cli, deeptide-gui) implements the production agent engine: an interactive REPL session with an agent loop, tool dispatch (bash, edit, web, git, memory, MCP, LSP, vision, cron, planning), cross-provider model routing with local-first/cloud-escalation policies, cost tracking, tokens-per-second telemetry, tool usage observability, durable memory with BM25 retrieval ranking, session import/checkpoint/rewind, sensitive-file read protection, and a theme system for syntax highlighting and diffs. The CLI and GUI share a common host layer, and the npm package downloads prebuilt Rust binaries. Architecturally it is a multi-crate Rust workspace plus supporting native components: native/ds4 is a hard-forked DeepSeek V4 Flash Metal inference engine for local LLM execution, and native/dsgo is a Swift gateway that translates between Anthropic and OpenAI protocols with SSE streaming. Primary entry points are crates/deeptide-cli/src/main.rs (CLI), crates/deeptide-gui/src/main.rs (eframe/egui GUI), and bin.js (Bun launcher that delegates to @paean-ai/zero-cli). External dependencies include DeepSeek/Anthropic/OpenAI-compatible APIs, local Metal GPU inference, and GitHub Releases for binary distribution. The repo also contains 50+ self-contained HTML5 Canvas pixel-art games and Three.js showcases under samples/, which appear to be AI-generated demo content demonstrating agent output quality rather than core product code. These share heavily duplicated boilerplate (seeded RNG, localStorage save/load, bilingual i18n, screen state machines). The core Rust code is well-tested with integration tests covering routing, cost tracking, memory ranking, tool result summarization, and slash commands; live API tests are marked #[ignore]. Hybrid note: while primarily an application, it contains research-oriented elements such as memory capture benchmarks (benchmarks/auto_capture_bench.py), prompt cache layout benchmarks (benchmarks/cache_memory_bench.py), and deterministic puzzle generation algorithms with uniqueness verification.
AsyncLocationKit is a pure Swift library that provides a modern async/await interface for Apple's CoreLocation framework. It eliminates the traditional delegate pattern by using a 'Performer' architecture where individual handlers (performers) process specific CoreLocation delegate callbacks and communicate results via Swift concurrency primitives like CheckedContinuation (for one-shot requests) and AsyncStream (for continuous monitoring). The library supports all major CoreLocation features: single location requests, continuous updates, region monitoring, visit monitoring, heading updates, beacon ranging, significant location changes, and authorization handling. It is thread-safe, uses zero external dependencies, and supports iOS, macOS, watchOS, and tvOS. The code is well-structured with clear separation of concerns, but the internal performer pattern is tightly coupled to CoreLocation event types, limiting direct extractability. Overall, it is a polished, production-ready wrapper that demonstrates strong Swift concurrency practices.
This repository is a curated list (awesome list) of Swift libraries, tools, and resources. It is not a software application or data pipeline. The primary artifact is a `contents.json` file that defines categories and projects, which is transformed into a `README.md` via a Ruby script (`convert.rb`) during CI. The repository includes contribution guidelines, a JSON schema, and GitHub Actions workflows for validation and deployment. It serves as a reference for Swift developers seeking high-quality open-source projects. There are no executable software components to reuse; the value lies in the curated list itself.
YPImagePicker is an iOS framework that provides an Instagram-like photo and video picker with a rich set of features including camera capture, library browsing, video trimming, photo filters, cropping, and multiple selection. The architecture follows a modular pattern with a central configuration struct (YPImagePickerConfiguration) that controls all behaviors, and a navigation controller (YPImagePicker) that manages a paged interface (YPPickerVC) switching between library, photo, and video screens. The library screen uses PHPhotoLibrary and PHCachingImageManager for asset fetching and caching, while the camera and video screens leverage AVFoundation for capture. Filters are applied via Core Image, and video trimming uses the PryntTrimmerView dependency. The framework is highly customizable through configuration properties for colors, fonts, icons, wordings, and feature toggles. The codebase is well-organized into folders for configuration, filters, helpers, models, pages (gallery, photo, video), and selections gallery. Helper extensions provide reusable functionality for AVFoundation, Photos, UIKit, and Core Image operations. The permission management is abstracted into a dedicated module. While the framework lacks unit tests and some view controllers are large, the overall structure is clean and the separation of concerns is reasonable. The library has been widely adopted (4.4k stars) and is actively maintained with recent commits and pinned dependencies.
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.
Turms is a production-grade, open-source instant messaging engine designed for 100K to 10M concurrent users. The system follows a microservices architecture with two core Java/Spring Boot servers: turms-gateway (handles client connections, authentication, session management, and push) and turms-service (implements business logic for messaging, groups, users, conversations, storage, and admin API). Both servers are built on a reactive stack (Project Reactor, Netty) for non-blocking I/O and high throughput. The platform includes a Vue.js admin UI (turms-admin), multiple client SDKs (JavaScript, Kotlin, Swift, Dart, C++), a Flutter chat demo, and a plugin system for extensibility (anti-spam, push notifications, MinIO storage, Rasa chatbot, LiveKit conferencing). Data is stored in MongoDB (sharded), Redis (session, blocklist, sequence IDs), and optionally Elasticsearch for full-text search. The codebase demonstrates strong engineering practices: custom RPC codecs for cluster communication, a property metadata framework for configuration validation, thread-safe rate limiting, and a well-defined plugin extension point system. While primarily an application, it includes an AI serving module (PaddleOCR) for content moderation, but this is a minor component. The repository is actively maintained with frequent commits, comprehensive CI/CD pipelines, and Terraform deployment scripts.
swift-sh is a CLI tool that enables Swift scripts to declare and fetch third-party dependencies via special comments in import statements. It parses a script's imports (e.g., `import Foo // @mxcl ~> 1.0`), generates a Swift Package Manager project with those dependencies, builds it, and runs the resulting executable. The architecture is modular with separate targets for script parsing (Script), command handling (Command), and utility functions (Utility). The tool supports both file-based and stdin scripts, local dependencies, and provides subcommands for ejecting to a full package and editing in Xcode (macOS only). It is a pragmatic solution that bridges the gap between ad-hoc scripting and SwiftPM's package structure.
Finch is a Swift CLI tool that generates well-formatted changelogs by comparing two Git versions (tags or branches). It parses commit messages using a configurable tag convention (e.g., `[feature]`) and groups commits into sections (Features, Bug Fixes, etc.) based on user-defined YAML configuration. The tool supports custom format strings with placeholders for tags, messages, contributor handles, and commit hyperlinks, as well as cascading configuration merging from multiple file locations. It is built with SwiftCLI for command routing, Yams for YAML parsing, and the Version library for semantic versioning. The architecture is modular with separate targets for core models, app logic, and utilities, and includes comprehensive unit and snapshot tests.
Swabble is a macOS 26 CLI daemon and Swift library that listens to the microphone, detects a configurable wake word (default 'clawd'), transcribes speech locally using Apple's Speech.framework (SpeechAnalyzer + SpeechTranscriber), and executes a user-defined shell hook with the transcript. It also supports offline file transcription to TXT or SRT. The architecture is a monolith Swift package with a library target (SwabbleCore) exposing reusable components like the speech pipeline, hook runner, config loader, and transcript store, and an executable target (SwabbleCLI) using the Commander library for command routing. Key data flows: microphone audio β AVAudioEngine tap β BufferConverter β SpeechAnalyzer β SpeechTranscriber β async stream β wake-word matching β HookRunner β shell process. External dependencies are limited to Apple frameworks and the Commander package. The codebase demonstrates strong use of Swift 6.2 concurrency (actors, async streams), careful process management with timeout and cancellation, and clean separation of concerns. It is well-tested with CI covering formatting, linting, unit tests, and release verification.
xtool is a cross-platform CLI tool and Swift library that enables building, signing, and deploying iOS applications without requiring Xcode. It serves as a replacement for Xcode's build-and-deploy pipeline, supporting macOS and Linux (via Docker). The core library, XKit, provides modules for interacting with Apple Developer Services (certificates, provisioning profiles, devices), implementing Apple's GrandSlam authentication protocol (including Anisette data), code signing via zsign, and device installation via libimobiledevice. The tool also includes a packaging subsystem (PackLib) that resolves SwiftPM dependencies, builds the app, signs it, and bundles it into an .app or .ipa. It supports both free and paid developer accounts and can automatically manage capabilities and provisioning profiles. The architecture is modular, with clear separation between CLI commands (XToolSupport), core library (XKit), and packaging logic (PackLib). It uses modern Swift concurrency (async/await, actors) and dependency injection via swift-dependencies. The codebase includes generated OpenAPI client for Apple's REST API, cross-platform HTTP client abstraction, and utilities for ZIP compression, temporary files, and key-value storage. Examples and integration tests verify functionality. While primarily a developer tool for side-loading and CI/CD for iOS apps, it also exposes the underlying libraries as SwiftPM dependencies for programmatic use. The codebase demonstrates good engineering practices with protocol-oriented design, clean abstractions, and testability. However, it relies on private Apple APIs and a large number of external dependencies, which introduce maintenance risks. The generated OpenAPI client and platform-specific device interactions add fragility, but the core patterns are well-implemented.
VirtualBuddy is a macOS-native virtual machine manager built on Apple's Virtualization framework. It allows developers to create, configure, run, and manage macOS and Linux virtual machines on Apple Silicon hardware, primarily for testing applications across different macOS versions. The system provides a full SwiftUI/AppKit GUI, a command-line tool (vctool), an XPC service for device restoration, and a guest application that runs inside VMs for clipboard sharing, file transfers, and configuration import. It manages the complete VM lifecycle: provisioning from IPSW restore images or Linux ISOs, hardware configuration (CPU, memory, storage, network, USB passthrough), boot/pause/resume, saved session save/restore with atomic file operations, and enterprise managed preferences via MDM. The architecture is modular with separate frameworks (VirtualCore, VirtualUI, VirtualWormhole, DeepLinkSecurity, VirtualInstallation) and a clear separation between UI, logic, and communication layers. External dependencies include Sparkle for updates, VMBridge for guest-host communication, and Apple's private MobileDevice framework for device restoration. The codebase exhibits high craftsmanship with well-structured concurrency (async/await, actors, Combine), extensive use of SwiftUI patterns, and robust state machines for session lifecycle and installation. However, heavy reliance on private Apple APIs and version-conditional compilation introduces medium technical drift risk, and the overall complexity is significant.
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.
This repository is a collection of iOS application projects that recreate various UI designs from sources like Instagram, Dribbble, and Facebook. Each project is a self-contained iOS app implemented in either Swift (UIKit) or SwiftUI, demonstrating how to translate specific designs into functional code. The repository serves as an educational resource for iOS developers looking to learn practical UI implementation techniques. The project follows a clear organizational structure where each episode resides in its own folder containing a downloadable ZIP file with the complete source code. Projects cover a wide range of UI concepts including onboarding flows, social media interfaces, messaging apps, music players, and more. Both UIKit and SwiftUI implementations are showcased, reflecting the evolution of iOS development practices. While the actual implementation details are contained within the ZIP archives and cannot be directly inspected in this repository view, the consistent naming convention, clear documentation in README.md, and regular maintenance indicate a well-organized educational resource. The repository appears to be actively maintained with recent commits and covers contemporary iOS development topics.
CrawlBar is a native macOS menu bar application and CLI tool that serves as a control plane for local-first crawler CLIs (e.g., GitHub, Slack, Discord, Telegram, Notion, WhatsApp). It discovers crawler manifests (built-in or from ~/.crawlbar/apps/), runs commands to retrieve status, freshness, and database inventory, and supports actions such as sync, publish, doctor, search, and backup. The architecture is strictly layered: a core library (CrawlBarCore) with no UI imports provides all data models, command execution, secret redaction, status normalization, and config storage, while a SwiftUI/AppKit frontend renders a menu bar status item and a settings window. A CLI (crawlbarctl) exposes the same functionality outside the GUI. CrawlBar does not crawl data itself; it orchestrates external CLI crawlers via a standardized manifest and status protocol (crawlkit.control.v1). It enforces privacy by redacting secrets from command output, storing action logs with private permissions, and keeping secrets in the macOS Keychain. The system supports remote execution via SSH and integrates with Cloudflare D1 for remote SQLite archives. 12 built-in crawler manifests are provided, covering major messaging and productivity platforms. The project also includes an extensive self-test suite, CI/CD with notarization, and a quality rubric document for code reviews. The core domain is well-abstracted, with reusable patterns for command running, status mapping, config caching, and action coordination. However, the codebase is macOS-only, relies on hardcoded fallback paths and a manual TOML parser, and has many per-crawler special cases in command argument construction. The maintenance is active (frequent releases, changelog, CI), but technical drift is medium due to ecosystem lock-in and custom infrastructure.
InjectionIII is a macOS menu bar application that enables hot reloading of Swift, Objective-C, and C++ code in iOS simulators and devices. It works by watching for source file changes, recompiling them using Xcode build logs, and dynamically loading the resulting dylib into the running app using techniques like interposing, vtable patching, and Objective-C swizzling. The app consists of a daemon with a file watcher and injection server, while the client-side code (bundled as injection bundles or via the HotReloading Swift package) handles compilation and injection. It supports standalone injection without the app running, injection on real devices, and integration with SwiftUI. The codebase is mature and actively maintained, though it contains legacy C/ObjC components and is tightly coupled to Xcode build log parsing.
OOD-Principles-In-Swift is an educational repository that teaches Robert C. Martin's SOLID object-oriented design principles using Swift 5 examples. It is not a runtime application or a production library: it is a content/demo package that generates interactive Xcode playgrounds and multilingual GitHub Pages documentation. The canonical code lives in source/SOLID/*.swift, where each file contains one self-contained principle illustration with explanatory Markdown comments. Bash scripts named generate-playground-*.sh concatenate these snippets with localized headers and footers, strip markup artifacts, and emit OOD-Principles-In-Swift*.playground/contents.swift plus README-*.md for a dozen languages. When consumed, the primary entry point is OOD-Principles-In-Swift.playground/contents.swift, which renders five SOLID sections in Xcode's playground UI. The repo also acts as a Jekyll site via _config.yml and _layouts/default.html, hosting the translated READMEs on GitHub Pages. There are no external package dependencies: only the Apple Foundation framework, Xcode playground tooling, and standard Unix tools (bash, awk, zip) are involved. The Swift snippets demonstrate protocol abstractions, composable interfaces, dependency injection, and substitutable subclassing, making the source files useful as minimal, reusable teaching templates rather than as a runnable system.
Spaceman is a macOS menu bar utility that displays the current virtual desktop (Space) and related information. It uses private CGS APIs to observe space changes and renders a custom icon in the status bar showing the active space, fullscreen apps, and multi-display gaps. The app supports multiple display styles (rectangles, numbers, named spaces) and allows users to name spaces. The architecture follows a simple MVVM pattern with AppKit for the status bar and SwiftUI for preferences. It integrates Sparkle for automatic updates, LaunchAtLogin, and KeyboardShortcuts for a force-refresh shortcut. The codebase is well-structured, with clear separation of concerns, though it is tightly coupled to macOS-specific APIs and the Spaceman domain.
This repository is the official archive and static site for 'θεΈζΊ iOS ε¨ζ₯' (Senior Driver iOS Weekly), a long-running curated newsletter for iOS developers. The project spans from 2018 to the present (2026) and contains over 380 weekly issues stored as structured Markdown files. While the core content is a curated list of articles, tools, and news, the repository also includes a build pipeline and a single-page application (SPA) that generates a searchable, full-text archive deployed to GitHub Pages. The architecture is a hybrid of content repository and static site generator: the `scripts/build-index.js` script parses the Markdown files, extracts metadata (sections, recommenders, reading time), and builds a search index using MiniSearch with CJK tokenization. The `docs/` directory contains the resulting SPA (`app.js`, `index.html`) and vendored libraries. The CI workflow (`.github/workflows/pages.yml`) automates building and deploying. The project is community-driven, with contributions submitted via GitHub Issues. It is actively maintained with recent updates, and the codebase is focused on reliable content delivery rather than complex application logic.
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.
TmpDisk is a macOS status-bar utility for creating and managing RAM-backed temporary disks (tmpfs/hdiutil volumes). It is a native AppKit/Cocoa application composed of four targets: a menu bar app, a privileged XPC helper installed via launchd, a sandboxed login launcher, and a command-line tool. The main app exposes create/eject/save/list workflows through the status bar menu and a GUI, while privileged operations such as mounting and configuring filesystems are delegated to an XPC helper that validates clients via audit tokens. The CLI communicates with the app through a named pipe, and volume configurations are persisted as .tmpdisk JSON metadata. The system relies heavily on macOS system tools such as hdiutil, diskutil, mount_tmpfs, mdutil, and rsync, and uses Sparkle for updates. This is purely an application repository; there are no data pipelines, notebooks, or research components.