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.
Snowflake is an SVG rendering library for iOS/macOS that parses SVG XML data and renders it using native CALayer and UIBezierPath. The architecture follows a modular design with separate components for document parsing, SVG element handling, style interpretation, path parsing, and utility functions. Key entry points are Document.init(data:) for parsing SVG data and SVG.view(size:) or SVG.layers(size:) for rendering. The library transforms SVG elements into shape objects that create UIBezierPath instances, which are then converted to styled CAShapeLayer objects for display. It supports inline styling, CSS-style attributes, animations, scaling, and base64-embedded images.
Swarm is a production-grade Swift-native agent runtime framework for building multi-agent conversational systems with type-safe tools, on-device Apple Foundation Models, composable workflows, memory, guardrails, and observability. The architecture is modular: core agent execution (Agent, Workflow, Job) with pluggable inference providers (Foundation Models, OpenAI-compatible, mock), memory backends (conversation, sliding window, summary, vector, persistent via SwiftData or Wax SQLite), and tool integration (built-in tools, MCP protocol, web search). Key entry points include Agent.run()/stream(), Workflow.execute(), and the SwarmMCPServerService for exposing tools via MCP. Data flows involve agent turns with tool calls, memory retrieval/consolidation, and durable workflow checkpointing via the HiveCore deterministic runtime. External dependencies include Apple FoundationModels (macOS 26+), swift-log, swift-syntax (for macros), and optional Wax (SQLite vector store) and OpenTelemetry SDK. The framework emphasizes compile-time safety via @Tool and @Agent macros, and provides resilience patterns (retry, fallback, circuit breaker, rate limiting) and observability (tracing, metrics, OpenTelemetry).
Kazumi is a cross-platform Flutter application for browsing, collecting, and streaming anime (番剧). At its core, it provides a curated media experience: users can discover anime via popularity rankings, weekly schedules, text and image (trace.moe) search; manage a local watchlist synced with Bangumi (bgm.tv) and WebDAV; and play videos using a hardware-accelerated media_kit (libmpv) player with danmaku overlay, Anime4K super-resolution shaders, Picture-in-Picture, and external player support. It also downloads episodes (HLS segments) for offline playback and supports synchronized group viewing via the Syncplay protocol. The application is built as a Flutter monolith with modular routing (flutter_modular), reactive state management (MobX), local storage (Hive), and a custom plugin system that defines scraping rules (XPath/API) to extract video sources from third-party websites. External dependencies include Bangumi, DanDanPlay, trace.moe, WebDAV servers, and a GitHub-hosted plugin catalog. The codebase demonstrates mature engineering practices including well-isolated async utilities, event-sourced history sync with conflict resolution, and platform-specific WebView integrations for video source extraction and captcha handling.
Fyne is a cross-platform GUI toolkit for the Go programming language, designed to build native desktop, mobile, and web applications from a single codebase. The repository contains the core framework including window management, event handling, a rich set of widgets (button, label, entry, list, table, tree, etc.), canvas primitives (lines, rectangles, arcs, text), layout managers, data binding, theming, storage abstraction, and platform-specific drivers (GLFW for desktop, mobile for Android/iOS, WebAssembly, and an embedded/no-OS driver). It also provides a command-line tool (`cmd/fyne`) for packaging, bundling resources, and releasing applications. The architecture is modular with clear interfaces (`fyne.App`, `fyne.Window`, `fyne.Widget`, `fyne.Canvas`) and extensive use of build tags for platform adaptation. The codebase is production-grade, well-tested with both unit and visual regression tests, and actively maintained by the Fyne community.
FluidVoice is a macOS desktop application for real-time voice dictation, meeting transcription, and AI-powered text enhancement. It provides a local-first dictation experience with on-device speech recognition (Parakeet, Nemotron, Whisper, Apple Speech) and optional cloud AI post-processing. The application features a command mode for AI chat, meeting recording with speaker diarization and acoustic echo cancellation, and a local HTTP API for external integrations. The architecture is a native SwiftUI/AppKit application with a service-oriented design. Audio capture uses CoreAudio and ScreenCaptureKit, with a vendored WebRTC audio processing stack for echo cancellation (AEC3), noise suppression, and voice activity detection. Speech recognition is handled by multiple providers, with model downloads from Hugging Face. The application includes a durable PCM storage system with chunk ledger for meeting audio, a signed model release feed for secure updates, and a comprehensive settings/persistence layer using SQLite and UserDefaults. Key entry points include FluidApp.swift (main application), LocalAPIRouter.swift (HTTP API server), MeetingSummaryProvider.swift (AI meeting summaries), ASRService.swift (speech recognition orchestration), and DictationAppSession.swift (dictation workflow). External dependencies include macOS system APIs, SQLite, vendored WebRTC audio processing, and various AI provider APIs (OpenAI, Anthropic, etc.). The repository also contains research-grade audio processing code (WebRTC AEC3, AGC2, RNN VAD) and pronunciation learning evaluation tools, but the dominant character is a production macOS application with extensive testing and CI/CD.
This repository provides a tool for spoofing Apple's network-based location service (WLOC) on iOS devices. It intercepts HTTP requests to `gs-loc.apple.com` via proxy tools (Surge, Quantumult X, Loon, Stash, Shadowrocket) and modifies the response to return user-defined coordinates. The system includes a Cloudflare Worker that serves a web-based map interface for selecting locations and an API for parsing map links from various services (Apple Maps, Google Maps, Amap, Baidu) with automatic coordinate system conversion (GCJ-02, BD-09, WGS84). The architecture is client-server: the proxy tool runs on the iOS device, while the Worker is stateless and handles the UI and link parsing. The codebase is well-structured, with clean separation between the Worker application, proxy scripts, and configuration modules. The coordinate parsing and conversion logic is particularly sophisticated, handling edge cases like Hong Kong boundary detection and Baidu's non-standard Mercator projection. The repository includes comprehensive regression tests and detailed documentation.
react-native-config is a native module library that exposes environment variables from a .env file to React Native applications on iOS, Android, macOS, and Windows. At build time, platform-specific scripts (Ruby for iOS/macOS, Gradle for Android, Node.js for Windows) parse the .env file and inject the key-value pairs as generated constants — BuildConfig fields on Android, a #define'd NSDictionary on iOS, and C++ string constants on Windows. At runtime, a single JavaScript entry point (index.js) calls a synchronous TurboModule method (getConfig()) to retrieve the config object, which is then exported as the default 'Config' constant. The library supports per-environment configurations via ENVFILE or per-build-configuration settings, and includes thorough diagnostics: if the .env file is missing or empty, the runtime logs a detailed message naming exactly which paths were tried. The codebase is well-structured across all four platforms, with a strong test suite for the iOS codegen scripts (Ruby Minitest) and a clean separation between build-time codegen and runtime reading.
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.
This is a Kotlin Multiplatform application that provides a movie and TV show browsing experience across Android, iOS, Desktop, and Web platforms. The app fetches data from The Movie Database (TMDB) API and displays content including now playing movies, popular/top-rated/upcoming movies and TV shows, celebrity information, and search functionality. It follows MVVM architecture with Clean Architecture principles, using Koin for dependency injection, Kotlin Coroutines for asynchronous operations, Ktor for networking, and Compose Multiplatform for the UI layer. The application includes features like favorite management with local storage, genre filtering, and detailed views for movies, TV shows, and celebrities.
learnX is a React Native/Expo mobile application designed for Tsinghua University students to access the Web Learning platform (learn.tsinghua.edu.cn). It provides features such as SSO authentication, course management, assignment tracking, file handling, calendar synchronization, and course information sharing via the courseX platform. The app uses Redux for state management, React Navigation for routing, and React Native Paper for UI components, with TypeScript ensuring type safety. It includes background data synchronization and supports iOS, Android, macOS, and Windows (via WSA).
Camposer is a Kotlin Multiplatform camera library that provides a unified Compose Multiplatform API for camera functionality on Android (via CameraX) and iOS (via AVFoundation). It offers camera preview, photo capture, video recording, flash/torch control, zoom, tap-to-focus, exposure compensation, mirror mode, multi-lens selection, video stabilization, and image analysis (including barcode/QR scanning via the optional code-scanner module). The library is published on Maven Central and includes sample apps demonstrating both Android-only and cross-platform usage. The architecture follows a clean separation of concerns with an internal engine/applier layer: `CameraState` holds reactive state flows for all configurable properties, and platform-specific appliers (`PreviewApplier`, `VideoApplier`, etc.) write changes to the underlying hardware when the state changes. The public API exposes `CameraPreview` composable, `CameraSession` for state/info access, and `CameraController` for capture commands. The codebase is well-structured with expect/actual pattern, version catalogs, ABI validation, and extensive test infrastructure (unit tests, device tests, iOS tests). It is a well-crafted, actively maintained library with high reusability potential.
RustDesk is a full-featured, open-source remote desktop application written primarily in Rust with a Flutter frontend. In production, it enables remote control, file transfer, clipboard synchronization, audio/video streaming, TCP tunneling, printer sharing, and camera streaming across Windows, macOS, Linux, Android, and iOS. The architecture is a client-server model with a rendezvous/relay server for NAT traversal, a plugin system for extensibility, and platform-specific backends for screen capture (DXGI, X11, Wayland, Quartz, Android MediaProjection), input simulation (enigo), and clipboard file transfer (RDP-based protocol with FUSE on Unix). Key entry points include `src/main.rs` (CLI), `src/server.rs` (host service), `src/client.rs` (remote session), and the Flutter UI in `flutter/`. Data flows involve encrypted peer-to-peer connections (NaCl), adaptive video codec selection (VP8/VP9/AV1/H264/H265 with hardware acceleration), and IPC via named pipes with OS-level authentication. External dependencies include libvpx, libyuv, FFmpeg, Opus, and platform-specific SDKs (Windows IddCx, macOS CoreGraphics, Linux Wayland/D-Bus). The codebase is actively maintained with frequent commits, CI/CD pipelines, and a large community (120k+ stars).
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.
Outline Apps is a production-grade, open-source VPN ecosystem consisting of two primary applications: a cross-platform VPN client and a server manager. The client, built for Windows, macOS, Linux, Android, iOS, and the web, connects users to Shadowsocks-based proxy servers by creating a system TUN/TAP interface and relaying packets through a Go-based tun2socks core. It exposes a unified TypeScript UI across Electron, Cordova, Capacitor, and browser shells, with native VPN lifecycle management implemented in Go, Java/Kotlin, Swift/Objective-C, and C#. The server manager is an Electron/desktop and web application that provisions and administers Outline servers on DigitalOcean, Google Cloud, AWS Lightsail, and arbitrary Linux machines, including access-key management, bandwidth metrics, data limits, and OAuth-based cloud onboarding. The architecture is a monorepo that separates a Go networking core, TypeScript web UI layers, platform-specific native bridges, and an infrastructure library of shared utilities. The codebase demonstrates careful engineering in several areas: a composable YAML configuration registry for transport strategies (Shadowsocks, WebSocket, TCP/UDP, multi-hop), a generic IP routing table for split tunneling, structured cross-language error types, and a consistent method-channel abstraction for JavaScript-to-native IPC. Strong test coverage exists across Go packages, TypeScript modules, and native platform code, supported by an extensive CI matrix. However, the repository carries significant technical debt from an incomplete migration from Polymer to Lit, the coexistence of legacy Cordova and newer Capacitor mobile stacks, and numerous platform-specific build scripts. This is squarely an application repository, not a data or research project. The only data-related aspects are telemetry and anonymized usage metrics sent to Sentry and server-administrator-controlled collectors, which are operational concerns rather than research pipelines. Maintenance activity is current, with frequent commits, active issue triage, and a large contributor base, but the broad platform surface and legacy framework overlap make ongoing modernization costly.
Saber is a production-grade, cross-platform Flutter application for handwritten note-taking. It is a monolith app with a few standalone packages: a custom vector-ink canvas engine (pen, pencil, highlighter, shape pen, laser pointer), page-based editor, image/PDF/SVG insertion, Quill text overlays, background patterns, shape recognition, and undo/redo. The main entry point is lib/main.dart, which wires routing, i18n, Sentry consent, sharing intents, and background sync. Notes are stored as versioned binary .sbn2 files via the self-contained packages/sbn library, with legacy .sbn support and migration logic. The application persists notes through a file manager responsible for CRUD, import/export, recently-used tracking, and directory watching. Nextcloud sync is implemented over WebDAV with client-side end-to-end encryption: file paths are hex-encrypted, content is encrypted, and conflicts are resolved using last-modified timestamps and a best-file strategy. Settings are managed through typed stow preferences and a large settings surface covering theme, writing tools, editor behavior, performance, and error reporting. Platform runners exist for Android, iOS, macOS, Windows, and Linux, with distribution metadata for Play Store, F-Droid, Flathub, AppImage, Snap, and Windows installers. The codebase is well-tested with unit, widget, golden, and format-compatibility tests, plus CI workflows for all major platforms. It is not a data/research repository; there are no notebooks, ML pipelines, or analytical datasets. Technical drift is moderate: the interactive canvas is a maintained fork of Flutter's InteractiveViewer, some dependencies are pinned or patched for F-Droid builds, and generated i18n files plus legacy format migration code require ongoing upkeep. Overall, this is a mature, actively maintained application with several cleanly separated components that can be reused in other Flutter projects.
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.
Ente is a multi-product, end-to-end encrypted cloud platform providing photo storage (Ente Photos), two-factor authentication (Ente Auth), secure document vault (Ente Locker), social photo sharing (Ente Space), AI chat assistant (Ente Ensu), ephemeral pastebin (Ente Paste), and media casting (Ente Cast). The system is built as a monorepo with a Go server backend, Rust core libraries for cryptography, machine learning, and media processing, and client applications across web (React/Next.js), mobile (Flutter, native Android/iOS), desktop (Electron), and CLI (Go and Rust). Architecture follows a zero-knowledge design: all encryption (XChaCha20-Poly1305, Argon2, X25519) happens client-side, with keys never exposed to the server. The server handles user accounts, file storage (S3-compatible), billing (Stripe), ML indexing, and sharing. Key entry points include the Go server at `server/cmd/museum`, Rust WASM bindings for web crypto, and Flutter apps with native plugins. Data flows involve client-side encryption before upload, server-side metadata storage in PostgreSQL, and decryption on download. External dependencies include PostgreSQL, S3-compatible object storage, Stripe, ONNX Runtime for ML, and various cloud infrastructure (Cloudflare Workers, Grafana, Prometheus).
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.