Pikapika is a cross-platform comic reader and downloader built with Flutter and Go, providing an ad-free experience for reading manga and comics. The application supports Windows, macOS, Linux, Android, and iOS, offering features such as browsing comics by category, searching, reading online or offline, managing downloads, favoriting content, viewing and posting comments, and downloading games. It includes a pro tier that unlocks advanced features like batch operations and extended export capabilities. The architecture separates the Flutter-based UI from a Go-based core backend, communicating via MethodChannels on mobile and go-flutter plugins on desktop. Local data storage for settings, favorites, and download history is managed through a central Method service. The UI is composed of reusable widgets organized in a component library, including specialized widgets for displaying comics, handling asynchronous states, and managing user interactions. Settings are implemented as individual classes that persist user preferences and broadcast changes via an event bus. Key entry points include platform-specific native code (MainActivity for Android, AppDelegate for iOS, etc.) and Flutter's main.dart/main_desktop.dart. Data flows involve user interactions triggering API requests through the Method service, which communicates with the Go backend to fetch or process data, then updates the UI accordingly. The application relies on various Flutter plugins for permissions, file handling, networking, and UI enhancements, while the Go core handles core logic and API interactions. We note that the project is actively maintained with recent commits and a low level of technical drift, indicating ongoing compatibility with current dependencies and platform SDKs.
This repository implements a comprehensive, production-grade CLI tool (`asc`) for interacting with Apple's App Store Connect API, Apple Ads API, and Apple Developer Portal. It automates the entire lifecycle of Apple platform applications, including authentication, app and build management, versioning, localization, screenshots, pricing, subscriptions, in-app purchases, Game Center features, code signing, distribution, and publishing. The tool is designed for CI/CD integration and supports multiple output formats (JSON, table, markdown) with a rich set of validation and diagnostic capabilities. The architecture is a monolithic CLI application built on a custom Go-like language with a sophisticated build system (`go.mod`, `go.sum`, `//go:build` directives). It follows a clean layered architecture: a command layer using the `ffcli` library, a comprehensive API client layer (`internal/asc/`), a secure authentication layer (`internal/auth/`), and platform-specific implementations for file operations, process management, and security. The codebase is exceptionally well-tested with thousands of unit and integration tests, including platform-specific tests for Darwin, Linux, and Windows. Notable engineering highlights include a generic pagination system with cycle detection, a registry-based output rendering system, a robust validation framework with structured remediation, and cross-platform secure file operations that prevent symlink attacks using platform-specific syscalls. The project also features an embedded workflow engine, telemetry with environment detection, and agent skill definitions for AI-assisted development workflows. The project is actively maintained with a structured release process, low issue count, and active dependency management. Technical drift is managed through explicit deprecation handling and migration paths. Primary risks include reliance on a custom Go toolchain, platform-specific assembly code for macOS security operations, and web session scraping that is inherently fragile to Apple Developer Portal changes.
This is a monorepo for React Native Elements (RNE), a cross-platform UI component library for React Native. It provides over 30 customizable components (Button, Input, Avatar, Card, ListItem, etc.) with a consistent API and a powerful theming system via ThemeProvider, createTheme, and makeStyles. The codebase is split into two packages: @rneui/base (core components with raw props) and @rneui/themed (themed wrappers that inject theme context). The library is actively maintained with extensive CI/CD (unit tests, lint, type-check, Expo previews, automated doc generation) and a comprehensive Docusaurus documentation site with versioned docs and interactive playgrounds. The architecture follows a clean separation of concerns: base components are stateless and theme-agnostic, while themed components add theme integration via a withTheme HOC. The code demonstrates solid engineering practices: functional components with hooks, Pressable-based interactions, lazy-loaded icon sets with deprecation handling, and a flexible rendering utility (renderNode). While the component surface is large and some tests are snapshot-only, the overall structure is well-organized and the theming pattern is a standout reusable asset.
KSCrash is a production-grade crash reporting and system monitoring library for Apple platforms (iOS, macOS, tvOS, watchOS, visionOS). It captures Mach exceptions, Unix signals, C++ and Objective-C exceptions, main thread hangs, watchdog timeouts, and OS-level terminations (OOM, thermal, CPU, reboot). The library generates Apple-format crash reports with full backtraces, binary images, system state, and user-provided context. It also includes performance monitors for CPU usage, memory pressure, and boot time, as well as a sampling profiler. The architecture is modular: a low-level C core provides async-signal-safe stack unwinding (compact unwind, DWARF CFI, frame pointer), safe memory access, JSON encoding/decoding, and a key-value store. Higher-level Objective-C and Swift modules implement individual crash monitors (Mach, signal, NSException, C++ exception, zombie, watchdog, termination, lifecycle, resource, user info) that register via a plugin API. Reports are stored on disk with mmap'd sidecar files for cross-launch state, then processed through a filter pipeline (demangling, compression, JSON formatting, diagnostic analysis) and delivered via configurable sinks (HTTP, email, console). The library is distributed as Swift packages and CocoaPods pods, with extensive CI covering unit tests, integration tests, benchmarks, static analysis, and API stability checks. Key strengths include rigorous async-signal-safety in crash-time code, a lock-free binary image cache for fast symbolication, a streaming JSON codec with pluggable callbacks, and a sidecar system that persists monitor data across app launches. The codebase demonstrates high craftsmanship in low-level systems programming, concurrency, and Apple platform internals. While primarily a crash reporter, its monitoring and profiling capabilities make it a comprehensive observability tool for Apple applications.
Swift Confidential is a sophisticated code obfuscation tool designed to protect string literals in Swift applications from static analysis and reverse engineering. The system employs a modular architecture consisting of Core obfuscation algorithms, a public API with Swift macros, utility functions, a YAML-based configuration parser, and a command-line tool. It provides two primary usage methods: compile-time macros (#Obfuscate) that transform plain string literals into obfuscated versions with runtime decryption capabilities, and a YAML-driven approach where a CLI tool processes configuration files to generate obfuscated Swift code. The core innovation lies in how each obfuscation technique (compression, encryption, randomization) not only obscures the data but also hides metadata about the method used—such as obfuscating compression magic bytes, encrypting key placement based on nonce bits, and obscuring shuffle patterns. This dual-layer approach significantly increases resistance to reverse engineering attempts. The project demonstrates strong maintenance with recent activity, up-to-date dependencies, and comprehensive testing.
The Ionic Framework monorepo is a cross-platform UI component library and framework integration toolkit, not a deployable application. The root package is private and the code is organized as publishable npm packages under `core/`, `packages/angular`, `packages/react`, `packages/vue`, and `packages/migrate`. Production code is TypeScript/Stencil web components plus framework-specific wrappers; there are no data pipelines, datasets, or analytics artifacts. Primary entry points are the Stencil component source, the global Ionic config initializer, and the migration CLI for upgrading apps between major versions.
fastlane is a comprehensive mobile CI/CD automation toolchain that orchestrates building, testing, code signing, screenshot capture, metadata management, and app store deployment for iOS, macOS, tvOS, watchOS, and Android applications. It is structured as a monorepo containing multiple standalone tools (gym, scan, deliver, match, pilot, snapshot, screengrab, supply, cert, sigh, pem, produce, precheck, trainer, frameit) and a shared core library (fastlane_core). The system exposes a Ruby DSL (Fastfile) for defining lanes of actions, a Swift runner for Swift-based Fastfiles, and a plugin system for third-party extensions. Key entry points include the `fastlane` CLI, per-tool commands (e.g., `gym`, `scan`), and the `Fastlane::Runner` that executes lane definitions. Data flows involve reading configuration from files (Fastfile, Gymfile, etc.), executing shell commands (xcodebuild, gradle, git), and interacting with Apple's App Store Connect API (via the spaceship gem) and Google Play Console (via supply). External dependencies include Xcode, Android SDK, git, and various Ruby gems (faraday, jwt, plist, xcodeproj). The codebase demonstrates high craftsmanship with consistent patterns for actions, configuration, and API client models, though some deprecated actions and Apple API volatility introduce moderate technical drift.
BiTchat is a native Swift messaging application for iOS and macOS that provides secure, decentralized communication over Bluetooth Low Energy (BLE) mesh, with optional Nostr and Tor transport. The codebase implements end-to-end encryption using the Noise protocol (XChaCha20-Poly1305), Ed25519 signatures, prekey forward secrecy, and a vouching trust model. It includes rotating peer IDs, fingerprint verification, recognition tags that avoid leaking social graphs, and panic-wipe capabilities. The app is structured around SwiftUI views, view models, and coordinators, with a central ChatTransportEventCoordinator routing inbound transport events (messages, noise payloads, delivery status, verification, peer lifecycle) to the UI layer.
Gorush is a push notification microserver written in Go that delivers notifications to iOS (APNS), Android (FCM), and Huawei (HMS) devices. It exposes both an HTTP REST API (built with Gin) and a gRPC interface for high-performance integration. The system is designed for production use with configurable queue backends (local in-memory, NSQ, NATS, Redis), multiple workers, and pluggable statistics storage (memory, Redis, BoltDB, BuntDB, LevelDB, BadgerDB). It supports concurrent iOS push limiting, automatic retry on failure, feedback webhooks for asynchronous error reporting, and Prometheus metrics for monitoring. The architecture follows a clean producer-consumer pattern: incoming push requests are validated and enqueued, then processed asynchronously by workers that dispatch to platform-specific push services. The codebase is well-structured with clear separation of concerns across packages (app/, config/, core/, notify/, router/, rpc/, storage/, logx/, metric/, status/). It includes comprehensive test coverage, CI/CD pipelines, Docker/Kubernetes/AWS Lambda deployment support, and security scanning. The configuration system uses Viper with YAML files and environment variable overrides, with built-in validation and sensitive field redaction for safe API exposure.
This is a mature, cross-platform React Native bottom sheet library (`@lodev09/react-native-true-sheet`) that provides native-feeling sheets on iOS (UISheetPresentationController), Android (BottomSheetBehavior + CoordinatorLayout), and Web (forked Vaul drawer). It is built exclusively for React Native's New Architecture (Fabric) with shared C++ shadow nodes for synchronous per-detent layout. The library offers an imperative API via refs and a global static method registry, plus optional integrations with React Navigation (custom stack router and sheet navigator), Expo Router (Sheet layout), and Reanimated (worklet-driven position tracking). Key features include automatic detent sizing, peek detents, header/footer overlays, keyboard avoidance, stacked sheets, dimming, and a portal-based overlay for toasts/dialogs. The codebase demonstrates high craftsmanship with clean native delegates, extensive event handling, and thorough test mocks. It is actively maintained with multiple example apps, CI/CD, Maestro E2E tests, and a documentation site.
HevSocks5Tunnel is a lightweight, high-performance tun2socks proxy written in C. It creates a virtual TUN interface and forwards all TCP/UDP traffic through a SOCKS5 proxy, supporting IPv4/IPv6 dual-stack, UDP-in-UDP and UDP-in-TCP relay modes, optional local ICMP echo replies, and a mapped DNS feature for transparent DNS resolution. The architecture is monolithic but modular: a YAML-based configuration parser, platform-specific tunnel backends (Linux, FreeBSD, macOS, NetBSD, Windows via Wintun), and a session management layer built on top of lwIP and the hev-task-system cooperative multitasking library. It can be used as a standalone CLI tool, a static/shared library, or embedded via JNI on Android. The codebase demonstrates strong C craftsmanship with clean abstractions, efficient I/O patterns (ring buffer with iovec, scatter/gather), and careful platform abstraction.
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.
FDSoundActivatedRecorder is a Swift library for iOS that implements sound-activated audio recording. It automatically starts recording when sound exceeds a dynamic threshold and stops when silence is detected, saving the output as an m4a file with fade-in/fade-out to prevent clicks. The core logic uses a moving average of audio power levels to dynamically adjust trigger thresholds, making it robust to varying noise environments. Built with modern Swift concurrency (actor) for thread safety, it provides a delegate protocol for callbacks and metering updates. The library is self-contained, depends only on standard iOS frameworks, and includes an example app demonstrating integration via SwiftUI.
SwiftGen is a mature, production-grade Swift code generation tool that produces type-safe Swift (and Objective-C) code from project resource files. It parses asset catalogs, strings files, fonts, storyboards, JSON, YAML, plist, Core Data models, colors, and arbitrary files, then feeds the parsed context into Stencil templates to generate compile-time safe accessors. The tool is primarily a CLI executable (`swiftgen`) that can be integrated into Xcode build phases, but it also exposes a reusable framework (`SwiftGenKit`) for parsing and context generation. The architecture cleanly separates parsing (SwiftGenKit) from template rendering (Stencil) and CLI orchestration (SwiftGenCLI), with a YAML configuration file (`swiftgen.yml`) centralizing all inputs, outputs, and parameters. The codebase is well-tested with unit tests for each parser and template output comparison against extensive fixture files. It supports Swift 4 and 5 output variants, custom templates, and parameters like `publicAccess`, `bundle`, and `lookupFunction`. While the project has some deprecated features and a large fixture set, it is actively maintained with recent commits, a clear migration guide, and a robust release pipeline via GitHub Actions.
TTGTagCollectionView is a production-ready iOS UI library that renders collections of tags/chips in a flowing, wrap-aware layout. The two principal entry points are `TextTagCollectionView`, which displays styled text tags driven by a datasource of `TextTag` model objects, and `TagCollectionView`, a generic container for arbitrary `UIView` tags using a delegate/datasource pattern. Tags are plain in-memory model objects — there is no persistence, networking, or data pipeline. The library is Swift-first with an intentional `@objc` compatibility surface preserving the pre-3.0 Objective-C API, and it ships with CocoaPods and Swift Package Manager support plus a `TagCloudView` SwiftUI wrapper.
This repository is a high-performance React Native library (llama.rn) that enables on-device Large Language Model (LLM) inference on iOS and Android devices. It wraps the C++ llama.cpp core using JavaScript Interface (JSI) and TurboModules, allowing mobile applications to run GGUF-formatted models locally without cloud dependencies. The architecture consists of a TypeScript/JavaScript layer for the React Native interface, a C++ core for inference and model loading, and native modules for Android (Java/Kotlin) and iOS (Objective-C++). Key capabilities include hardware acceleration via Apple Metal and Qualcomm Hexagon DSP, multimodal support (vision/audio), parallel decoding, and structured output generation. The project includes a comprehensive example app demonstrating chat interfaces, model management, and benchmarking tools.
Swift Paperless is a native iOS client for Paperless-ngx, a self-hosted document management system. The app provides a rich SwiftUI interface for browsing, filtering, viewing, editing, and sharing documents stored on a remote Paperless-ngx server. It supports offline-first caching via GRDB (SQLite), multi-server connections, OIDC login with PKCE and TOTP, mTLS client certificates, deep links, and a share extension for importing documents from other apps. The architecture is modular, with separate Swift packages for networking (ApiRepository, wire types), data models (FilterState, SyncPlan), persistence (GRDB migrations, records, observation), and shared UI components. The app uses a repository pattern with a caching decorator (CachingRepository) that provides offline reads, delta sync with watermarks, and write-through cache consistency. A sync engine orchestrates per-server synchronization phases (elements, reconcile, fill) with progress reporting and throttle support. Key features include a customizable filter bar with saved views, custom field filtering with logical operators, a PDF viewer with text search, document scanning via VisionKit, barcode ASN extraction, and a tip jar for donations. The codebase is well-tested with unit tests for networking, persistence, data models, and concurrency patterns. CI/CD pipelines build and deploy to TestFlight, and localization is managed via Crowdin across 8 languages.
SwiftfulRouting is a programmatic navigation library for SwiftUI that replaces native NavigationStack, sheets, fullScreenCovers, alerts, and confirmationDialogs with a unified, declarative router API. It provides a `RouterView` wrapper which injects an `AnyRouter` into the environment, enabling screens, alerts, modals, transitions (in-place content swaps), and modules (full hierarchy replacements) to be triggered from anywhere in the view tree. The library uses an internal `RouterViewModel` to manage a stack of `AnyDestinationStack` entries representing the screen hierarchy, with separate state for alerts, modals, and transitions. It also includes queue systems for screens and transitions, logging/analytics support, and resizable sheet configuration. The architecture is a Swift Package with one external dependency (SwiftfulRecursiveUI for LazyZStack), and targets iOS 16+, macOS 12+, tvOS 14+.
react-native-haptic-feedback is a React Native library providing comprehensive haptic feedback capabilities for iOS and Android. It implements a dual-tier fallback chain on both platforms: iOS uses Core Haptics (CHHapticEngine) with UIKit generator fallback, while Android uses View.performHapticFeedback constants and VibrationEffect API. The library offers both simple trigger methods and complex pattern-based haptic sequences, includes cross-platform AHAP file playback with Android fallbacks, and provides React-first APIs like the useHaptics hook and TouchableHaptic component. Architecture features platform-specific native modules bridged via React Native's TurboModule system, with TypeScript source and auto-linking support.
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.