This repository provides a full‑screen modal view controller for cropping and rotating images on iOS, implemented as a reusable UIKit component library. The core controller (`TOCropViewController` in Objective‑C, `CropViewController` in Swift) manages a gesture‑driven crop view, a toolbar with rotation/reset/aspect‑ratio controls, a configurable grid overlay, and animated present/dismiss transitions. It supports both rectangular and circular cropping, aspect‑ratio locking, and device‑aware layout that adapts to safe areas, notches, and orientation changes. The architecture follows a classic MVC pattern within UIKit: `TOCropView` handles image display, crop‑box manipulation, pan/zoom, and rotation; `TOCropToolbar` provides adaptive button layouts; `TOCropOverlayView` draws the grid; and `TOCropScrollView` manages touch‑based scrolling. Image‑level crop and rotate operations are delegated to the `UIImage+CropRotate` extension, which performs pixel‑level transformations. The Swift wrapper uses bridging headers and closures to map the Objective‑C delegate protocol to Swift callbacks, demonstrating a clean cross‑language integration pattern. The library is distributed as a framework via CocoaPods and Carthage, includes unit tests (XCTest), CI/CD pipelines (GitHub Actions, Buildkite), and localization in over 30 languages. It depends only on UIKit and the iOS SDK, with no external runtime dependencies. The codebase is mature (first commit 2015) and actively maintained, though it contains iOS‑version‑specific conditionals (e.g., iOS 26 glass effects) and some deprecated APIs that indicate moderate technical drift. Several components are self‑contained and reusable: the `UIImage+CropRotate` extension for image processing, the `TOCropViewControllerTransitioning` animation controller, the `TOCropOverlayView` grid overlay, and the Swift bridging pattern. These can be extracted into other iOS projects with minimal modification.
Prefire is a Swift developer tool that scans SwiftUI source files, extracts `#Preview` macros and `PreviewProvider` declarations, and generates automated snapshot tests plus an interactive "Playbook" component catalog. It is not a data project: it is a CLI/code generator with a runtime library and SwiftPM/Xcode build-tool plugins. The real pipeline is: a build plugin invokes the `prefire` binary with target/source/config arguments; the binary parses sources using SwiftSyntax for `#Preview` macro ranges and a Sourcery fork for `PreviewProvider` types; a fingerprint-based cache avoids re-parsing unchanged files; Stencil templates (one for snapshot tests, one for playbook models) render generated Swift code; snapshot tests run against swift-snapshot-testing and the bundled Prefire runtime, while `PlaybookView` renders the generated `PreviewModels` inside an app.
Rectangle is a production macOS menu-bar window-management utility that moves, resizes, and tiles application windows through keyboard shortcuts and drag-to-snap. It is not a research or data project; it is a purely native desktop application. It reads and writes window geometry via the macOS Accessibility API (AXUIElement), supporting dozens of layout actions — halves, thirds, quarters, sixths, eighths, ninths, twelfths, sixteenths, maximize, center, cascade, display transfer, and multi-window grid/row/column tiling — plus stacked-window cycling, a todo-mode sidebar, cooperative corner resize, and an optional animation engine. Architecturally, this is a Swift/Cocoa menu-bar app (LSUIElement, no dock icon, no backend). AppDelegate wires together ShortcutManager (MASShortcut bindings), WindowManager (action orchestration), SnappingManager (drag-to-snap with placement preview), MultiWindowManager (tile/cascade/stack), and a SwiftUI Settings window backed by a typed Defaults system persisted in NSUserDefaults with JSON import/export. The heart of the layout logic is a strategy pattern: a WindowCalculation protocol with roughly a hundred small calculation classes, each implementing one placement, applied through a chain of WindowMover implementations (standard, fixed-size, best-effort, edge-alignment) and optionally a display-link-driven animation pipeline with pacing, settlement, and handoff verification. The primary data flow is user input (shortcut/menu/drag) → WindowAction enum → WindowCalculation produces a target rectangle from the current screen, window, and gap state → a WindowMover writes the frame through AXUIElement with edge correction, followed by optional animation and post-move verification. Screen detection, multi-display transfer, gap math, and stack detection are separated into focused utilities. External dependencies are limited to AppKit/QuartzCore, the undocumented macOS Accessibility API, a forked-and-pinned MASShortcut, and Sparkle for auto-updates. The codebase is professionally maintained with unit tests for geometry, grid tiling, stack detection, defaults serialization, and cooperative resize, plus GitHub Actions CI that produces signed DMGs. Its main weaknesses are scale-related: a monolithic calculation factory and a ~140-value WindowAction enum with duplicated metadata, a single ~96k-token test file, and near-duplicate calculation classes for fine-grained grids. The strongest reusable assets are generic utilities (TTL cache, debounce) and pure-geometry modules that are decoupled from app state.
ipatool is a cross-platform command-line tool that acts as an unofficial Apple App Store client. It enables searching, purchasing, and downloading iOS/iPadOS/tvOS/watchOS/visionOS/macOS applications and packages directly from Apple's servers. The tool implements Apple's private SAP authentication and signing protocol by emulating Apple's StoreAgent binary in-process using the Unicorn CPU emulator, allowing it to generate kbsync blobs and decrypt macOS packages. It also includes low-level parsers for Apple's proprietary formats (AEA encrypted archives, APFS filesystems, dyld shared caches) to extract assets from macOS restore images. The architecture is modular: a CLI layer (using cobra) dispatches to domain logic in pkg/appstore, which relies on a generic HTTP client (pkg/http), keychain storage (pkg/keychain), and platform abstractions (pkg/util). An MCP (Model Context Protocol) server subcommand exposes the same functionality over stdio. The codebase is heavily tested with unit and integration tests, and CI builds for macOS, Linux, Windows, and iOS. While primarily an application, it contains significant reverse-engineering and protocol-analysis components, giving it a hybrid character.
PureMac is a free, open-source macOS system cleaner and app uninstaller built as a native SwiftUI application (targeting macOS 13.0+). It provides a graphical interface and a companion CLI tool for scanning and removing junk files, uninstalling applications with full leftover cleanup, finding orphaned files, and performing scheduled maintenance. The system is architected with an MVVM-like pattern: a central `AppState` ObservableObject drives all UI state, while modular actors (`ScanEngine`, `CleaningEngine`, `BinaryThinner`) handle async scanning and cleaning operations with safety checks (path allowlists, symlink resolution, trash-only deletion). The app uses a 10-level heuristic to match app files, scans 12+ categories (system junk, user cache, Xcode, Homebrew, Docker, AI apps, etc.), and integrates with macOS services like Full Disk Access, Finder Services, Menu Bar, and Sparkle auto-updates. The CLI is a separate Swift package with its own set of commands (clean, purge, analyze, optimize, ignore, config) that reuses similar logic, ensuring consistency between GUI and terminal workflows. The codebase is well-structured, fully internationalized (10+ languages), and distributed via Homebrew and GitHub releases with a full CI/CD pipeline for signing and notarization.
MLX Swift is a Swift language binding for the MLX machine learning framework, providing a comprehensive library for building and training neural networks on Apple Silicon (Metal) and NVIDIA GPUs (CUDA). It offers automatic differentiation, a wide range of neural network modules (MLXNN), optimizers (MLXOptimizers), and support for custom JIT-compiled GPU kernels. The architecture is a Swift frontend wrapping a C/C++ backend, with auto-generated GPU kernels for high performance. It is primarily a library, not a standalone application, designed for integration into Swift projects via Swift Package Manager or Xcode. The codebase demonstrates high craftsmanship in Swift metaprogramming and GPU kernel optimization, though it carries some technical debt from vendored dependencies and dual build systems.
SFSafeSymbols is a Swift library that provides type-safe, compile-time checked access to Apple's SF Symbols. Instead of using string literals like `Image(systemName: "arrow.left")`, developers use generated static properties like `._arrowLeft` on the `SFSymbol` type, eliminating runtime crashes from typos and ensuring correct availability across OS versions. The library is distributed as a Swift Package, CocoaPod, and Xcode project, supporting iOS, macOS, tvOS, watchOS, and visionOS. It includes convenience initializers for SwiftUI (`Image`, `Label`, `Button`, `Tab`, `ContentUnavailableView`, `MenuBarExtra`), UIKit (`UIImage`, `UIApplicationShortcutIcon`), AppKit (`NSImage`), and AppIntents. The core architecture consists of a base `SFSymbol` class with `Codable` conformance and dynamic localization via `@dynamicMemberLookup`, plus thousands of auto-generated static properties organized by SF Symbols version. A companion command-line tool, `SymbolsGenerator`, parses Apple's metadata files (plists, strings) and produces the Swift source files, ensuring the library stays in sync with each OS release. The codebase is well-tested with unit tests for all framework extensions and runs CI on multiple Xcode versions and platforms.
SwiftPoet is a Kotlin/Java library for programmatically generating Swift source code. It provides a fluent builder API to construct Swift files with classes, structs, enums, protocols, extensions, functions, properties, type aliases, imports, attributes, documentation, and more. The library handles type name resolution, import management, keyword escaping, and proper formatting including indentation and line wrapping. It is inspired by JavaPoet and designed for use in annotation processing, metadata-driven code generation, and similar scenarios. The architecture is a pure library with no runtime dependencies beyond Kotlin stdlib, making it lightweight and embeddable. The codebase demonstrates strong software craftsmanship with clean abstractions, extensive test coverage, and reusable utility components.
MonitorControl is a macOS menu-bar utility that controls external displays' brightness, contrast, and volume. It does not just send one kind of command; it uses multiple control paths: hardware DDC/CI over IOKit I2C on Intel Macs, DDC/CI over IOAVService on Apple Silicon, Apple's private DisplayServices API for Apple/Thunderbolt displays, gamma-ramp adjustments for software dimming, and transparent shade windows for virtual displays. User input flows from native media keys, custom keyboard shortcuts, and menu-bar sliders into a DisplayManager singleton, which coordinates native OSD overlays, smooth brightness transitions, and cross-display synchronization. The app uses Sparkle for updates, SimplyCoreAudio for audio device handling, MediaKeyTap for media-key interception, and KeyboardShortcuts for user-defined bindings. Architecturally, this is a classic Cocoa application with a storyboard-based preferences UI, a login helper app (MonitorControlHelper), and a clean separation between models (Display, AppleDisplay, OtherDisplay), support services (DisplayManager, DDC backends, OSD utilities, media-key handling), and view controllers for preferences and onboarding. Entry points are main.swift, AppDelegate, DisplayManager, and MenuHandler. Persistence is UserDefaults backed through a PrefKey enum, and the UI is localized into 19 languages. There is no data/research component; this is purely an end-user utility. The codebase is modular and well organized, with the DDC communication isolated into Intel and ARM backends and display-specific logic abstracted behind a base Display class. It is actively maintained, with recent commits and a modern dependency setup. Technical drift is medium rather than low because much of the functionality depends on private or undocumented macOS APIs (DisplayServices, CoreDisplay, OSDUIHelper) and the code contains many macOS-version-specific workarounds, but the project tracks current macOS releases and continues to update its fallbacks.
XcodeGen is a command-line tool written in Swift that generates Xcode project files (.xcodeproj) from a declarative YAML or JSON specification (typically project.yml). It eliminates the need to manually manage Xcode project files by deriving the project structure from the filesystem and a concise spec, supporting all major Apple platforms (iOS, macOS, tvOS, watchOS, visionOS) and a wide range of product types including applications, frameworks, libraries, extensions, App Clips, and more. The tool integrates with Swift Package Manager, Carthage, and CocoaPods, and can generate schemes, breakpoints, Info.plist files, and build settings from layered presets. The architecture is modular: the ProjectSpec module defines the domain models and parsing logic for the spec format; XcodeGenKit contains the core generation logic (PBXProj generation, scheme generation, source file organization, settings resolution); XcodeGenCLI provides the command-line interface using SwiftCLI; and XcodeGenCore offers utility components like globbing, atomic properties, and path extensions. The tool is designed for automation and CI workflows, with caching support and pre/post generation commands. The codebase is well-structured with clear separation of concerns, extensive test coverage (unit tests, fixture-based golden tests, performance tests), and active maintenance. It demonstrates strong Swift engineering practices including protocol-oriented design, value types, and functional patterns. While the project is mature and widely adopted (over 8,800 stars), some areas like test fixtures are large and tightly coupled to specific Xcode versions, requiring periodic updates.
This repository is the open-source iOS client for Kickstarter, a crowdfunding platform. It is a production-grade application built with Swift, UIKit, and SwiftUI, following an MVVM architecture with heavy use of ReactiveSwift and some Combine. The app supports project discovery, pledging, rewards, comments, video feeds, user settings, and authentication. The codebase is well-structured with a dedicated design system (KDS), GraphQL integration via Apollo, extensive snapshot and unit testing, and feature flag experimentation via Statsig. While the code quality is high with many reusable patterns (ValueCell, ShimmerLoading, PaginatingList), there is moderate technical drift due to the coexistence of two reactive frameworks, legacy color references, and some deprecated button styles.
DeviceKit is a pure-Swift library that provides a value-type replacement for Apple's UIDevice. It detects the exact device model (iPhone, iPad, iPod, Apple Watch, Apple TV) via hardware identifiers obtained from the system's uname() and maps them to an exhaustive enum with over 150 cases. Beyond identification, it exposes a rich set of computed properties such as screen diagonal, PPI, screen ratio, battery state (iOS/watchOS), cameras, Apple Pencil support, CPU/SoC, 5G support, USB-C connectivity, LiDAR sensor, Dynamic Island, and more. The library is architected as a single source file (Device.generated.swift) generated from a Python template (Device.swift.gyb) that encodes per-device metadata. It uses platform compilation guards (os(iOS), os(tvOS), os(watchOS)) to provide platform-specific APIs, and includes an indirect .simulator case to propagate properties through to simulated devices. DeviceKit has no external runtime dependencies and is distributed as a framework via CocoaPods, Carthage, and Swift Package Manager. Its primary entry point is `Device.current`, returning the running device as a value type, with static helpers like `Device.allPhones` and instance methods like `isOneOf(_:)` for group checks.
CHTCollectionViewWaterfallLayout is a UICollectionViewLayout subclass that implements a Pinterest-like waterfall layout for iOS and tvOS. It provides a configurable multi-column grid that arranges items of varying heights into the shortest column first, with support for per-section headers, footers, column counts, insets, and spacing. The library is implemented in both Swift and Objective-C, distributed via CocoaPods and Swift Package Manager, and requires iOS 13+ / tvOS 13+. It does not depend on any third-party frameworks and is designed to be a drop-in replacement for UICollectionViewFlowLayout when a waterfall arrangement is desired. The Swift implementation (v1.0.0) is a complete rewrite with modern API conventions and improved type safety.
Rainbow is a zero-runtime-dependency Swift library that applies ANSI escape sequences to strings for colored terminal output. It supports the named 16-color palette plus light variants, 8-bit 256-color mode (38;5;N), 24-bit true color (38;2;R;G;B), hex colors approximated to the nearest 256-color cube, HSL colors converted to RGB, and styles (bold, dim, italic, underline, blink, swap, strikethrough). Output is gated by OutputTarget detection that checks isatty() on POSIX/Windows plus NO_COLOR/FORCE_COLOR environment variables, so redirected output degrades to plain text automatically.
Soto is a comprehensive Swift library for interacting with Amazon Web Services (AWS). It provides auto-generated, type-safe, async/await client code for over 300 AWS services, covering compute, storage, databases, machine learning, analytics, and more. The SDK uses a code generation pipeline (soto-codegenerator) that reads Smithy model files from the official AWS SDK Go v2 repository to produce Swift service structs, request/response shapes, paginators, and waiters. Beyond generated code, Soto includes handcrafted extensions for S3 (multipart uploads, presigned POST/URLs), DynamoDB (custom Encoder/Decoder to/from AttributeValue), and credential providers built on Cognito Identity and STS. The library depends on SotoCore for HTTP client, signing, and middleware infrastructure. It supports Linux, macOS, iOS, tvOS, and watchOS via Swift Package Manager.
JavaScriptKit is a production-grade Swift framework and Swift Package Manager plugin suite that enables bidirectional JavaScript interop for Swift code compiled to WebAssembly (WASM). The core runtime (JavaScriptKit) provides low-level types such as JSObject, JSValue, JSClosure, JSPromise, and JSBigInt, along with value conversion protocols (ConvertibleToJSValue, ConstructibleFromJSValue) and thread-local storage helpers. The BridgeJS plugin uses Swift macros (@JS, @JSFunction, @JSClass, etc.) to automatically generate Swift and JavaScript glue code, including WebAssembly export/import tables, stack-based marshalling, codec caches, and closure lifecycle management. The PackageToJS plugin packages the compiled WASM module into a deployable JavaScript package with platform-specific instantiation logic for browsers, Node.js, and WASI. The repository includes extensive snapshot-based code generation tests, runtime integration tests, benchmarks, and real-world examples (browser apps, Node.js servers, multithreading with web workers, OffscreenCanvas, actor-based concurrency). The architecture is a layered combination of a Swift library, Swift macros, a CLI tool (bridge-js), and SPM build plugins, all heavily dependent on WebAssembly-specific Swift features (@_expose(wasm), @_cdecl) and the Swift concurrency runtime. The project is actively maintained with a large test surface, but carries medium technical drift due to reliance on experimental Swift features and snapshot brittleness.
Stream Chat Swift is an iOS/macOS SDK for building real-time chat and messaging applications. It provides a modular architecture separating core networking (StreamChat), UI components (StreamChatUI), and shared utilities (StreamChatCommonUI). The SDK supports features like channels, messages, reactions, threads, polls, attachments, typing indicators, and presence. It uses Combine for reactive programming, Core Data for persistence, and WebSocket for real-time communication. The repository includes demo applications, example implementations (SlackClone, MessengerClone, etc.), and extensive testing infrastructure. The SDK follows protocol-oriented programming with dependency injection via Appearance and Components providers, enabling high customization.
swift-power-assert is a Swift library that provides a `#assert` macro, delivering detailed diagnostic diagrams for assertion failures. The macro, built on SwiftSyntax, rewrites expressions to capture intermediate values and renders a tree of sub-expression results on failure, including word/line diffs for string comparisons. It supports sync and async evaluation, short-circuiting, and custom operators, aiming to replace multiple assertion APIs (XCTest, Nimble, etc.) with a single, universal assert. The package also includes a `StringWidth` module for accurate Unicode width calculations and a comprehensive test suite (2300+ lines) covering diverse expression types. Additionally, the repository contains an interactive web playground with a Deno backend and Monaco editor, allowing users to test the macro in a browser. The codebase is well-structured, with clean abstractions in the runtime library and plugin, though the macro rewriter is tightly coupled to the capture pattern and the generated Unicode width table is large.
SwiftIO is a Swift framework for microcontrollers that provides an easy-to-use interface for hardware peripherals. It abstracts low-level hardware details into Swift classes, allowing developers to interact with GPIO, ADC, PWM, timers, communication protocols (I2C, SPI, UART), and more without dealing with complex register manipulation. The library is structured into a C layer (CSwiftIO) for direct hardware access and a Swift layer that wraps this functionality in a safe, idiomatic API. It emphasizes error handling through Swift's Result type and provides consistent patterns for resource management and peripheral interaction.
NativeScript is a mature, cross-platform mobile application framework that enables developers to build native iOS, Android, and visionOS apps using JavaScript, TypeScript, or Angular. The repository is structured as a monorepo containing the core runtime (`@nativescript/core`) with platform-abstracted UI components, styling engine, data binding, and application lifecycle management; dual build toolchains (`@nativescript/vite` and `@nativescript/webpack5`) with Hot Module Replacement (HMR) support; platform type definitions (`@nativescript/types-ios`, `@nativescript/types-android`); and native widget libraries (Android Java, iOS Objective-C). The architecture is component-based: XML-declared UIs are parsed by a builder, instantiate native views, and styled via a custom CSS engine with selector matching, inheritance, and animations. An extensible property system with coercion, CSS properties, and change tracking drives reactivity. HMR infrastructure includes a Vite plugin that serves modules over WebSocket with framework-specific strategies (Angular, Vue, Solid, TypeScript). The codebase is heavily tested with unit tests (Vitest), platform-specific integration tests, and Appium E2E tests. Reusable design patterns include the observable data binding, property change origin tracking, platform-qualified file resolution, and CSS media query parsing. Notable technical drift risks include the coexistence of two build systems (webpack5 deprecated in favor of Vite), extensive platform-specific code duplication (`.android.ts`/`.ios.ts` pairs), and reliance on some deprecated iOS APIs in type declarations. Overall, it is a well-engineered framework with a large ecosystem and active development.