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.
rules_ios is a Bazel rule set for building Apple platform applications (iOS, macOS, tvOS, watchOS). It provides rules for creating apps, frameworks, extensions, app clips, tests, and handling Apple-specific complexities like code signing, resource bundling, and multi-architecture support. The repository integrates with rules_apple and rules_swift, offering a Bazel-native alternative to Xcode builds. Key features include automatic handling of Apple Silicon compatibility via import_middleman, VFS overlays for faster builds, and comprehensive test generation. The tooling directory contains utilities like arm64-to-sim for running arm64 binaries in x86_64 simulators and SSH password helpers for VM-based testing.
This repository is a comprehensive collection of iOS demonstration projects covering design patterns, data structures, Swift language features, iOS frameworks, and software engineering principles. Each demo is a self-contained Xcode project or Swift playground that illustrates a specific concept through working code. The collection serves as an educational resource for iOS developers learning various aspects of iOS development, from basic Swift syntax to advanced frameworks like Core Animation and Combine. While individual demos vary in complexity and polish, they collectively provide valuable reference implementations of common iOS development patterns.
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.
Procursus is a specialized build system and package repository infrastructure designed to compile open-source software into Debian packages (.deb) for Apple platforms (iOS, macOS, tvOS, watchOS). It functions as a cross-compilation environment, orchestrating the fetching, patching, compilation, signing, and packaging of hundreds of packages using a monolithic Makefile-based architecture. The system is primarily used by the jailbreak and iOS development communities to provide a Debian-like package management experience on non-Linux Apple operating systems. The architecture relies heavily on custom build macros, platform-specific patches, and Apple SDK integration. Key entry points include the central Makefile for orchestration, build_tools/ for helper scripts, and makefiles/*.mk for individual package definitions. The system manages complex dependency chains and security entitlements required for iOS/macOS compatibility. While it solves a difficult cross-platform packaging problem, the codebase is tightly coupled to Apple's internal APIs and SDK versions, requiring constant maintenance to keep pace with OS updates.
This repository is a documentation-only collection of Apple Xcode user defaults (`defaults write` commands) and related shell one-liners. It contains no application code, libraries, tests, or executable entry points; the only substantive content is a large README that catalogs tweaks for Xcode's build system, Swift compiler parallelism, indexing, logging, simulator behavior, derived data cleanup, and related developer-experience settings. The README is organized by topic and cites sources for many of the tips, making it a curated cheat sheet rather than a software product. Because there is no codebase, there is no runtime architecture, API, or data flow. The repository's practical value is as a reference for iOS/macOS developers who want to tune Xcode behavior by copying commands into Terminal. The included GitHub Actions workflow only checks markdown links, and the renovate configuration manages dependency updates for a repository that has no actual dependencies. The CC BY-ND 4.0 license permits sharing with attribution but prohibits derivative works, which may limit how freely the curated content can be reused in other projects or tools.