EFQRCode is a pure-Swift, cross-platform Apple framework for generating stylized and highly customizable QR codes, and for recognizing QR codes from images. The core production code exposes two primary entry points: `EFQRCode.Generator` and `EFQRCode.Recognizer`. The generator accepts text/data input, encodes it using the external `QRCodeSwift` package, maps the resulting matrix through a strategy-based style hierarchy (`EFQRCodeStyleBasic`, `EFQRCodeStyleBubble`, `EFQRCodeStyleLine`, `EFQRCodeStyle25D`, `EFQRCodeStyleImage`, etc.), and produces SVG representations which are then rasterized by `SwiftDraw` into static images, PDFs, GIFs, APNGs, or AVFoundation-backed video files. The recognizer uses CoreImage-based detection with grayscale fallback and result caching. The library is heavily documented, supports iOS, macOS, tvOS, watchOS, and visionOS, and is distributed through SPM, CocoaPods, and Carthage. The `Examples/` directory contains demo apps for each platform that act as integration-style usage references, but these are example clients rather than the core deliverable. This is definitively an application/library repository; there are no data pipelines, notebooks, or research artifacts.
HealthGPT is an iOS application that enables users to interact with their Apple Health data using large language models (LLMs) in a conversational interface. Built on the Stanford Spezi modular framework, the app supports three LLM execution modes: remote OpenAI (GPT-3.5/4), on-device local models (Llama3 via MLX), and privacy-preserving fog nodes within the local network. The architecture follows a monolith application pattern with clear separation of concerns: HealthDataFetcher queries HealthKit for steps, sleep, heart rate, etc.; HealthDataInterpreter prepares the LLM context with a system prompt generated from the fetched data; and the SwiftUI ChatView manages the conversation flow. External dependencies include Spezi modules (HealthKit, LLM, Onboarding, Storage) and OpenAI API. The codebase is well-structured with SwiftLint enforcement, comprehensive UI and unit tests, CI/CD pipelines via GitHub Actions and Fastlane, and an automated TestFlight deployment workflow. While the app is tightly coupled to the iOS ecosystem and Apple HealthKit, the data fetching, prompt generation, and LLM orchestration patterns are cleanly abstracted and potentially reusable in other health-related Swift applications.
MuscleMap is a SwiftUI SDK for rendering interactive human body muscle maps with highlighting, heatmaps, and gesture support. It provides male and female body models in front and back views, supports tap/long-press/drag interactions, pinch-to-zoom, multi-select with undo/redo, pulse animations, and extensive localization (11 languages). Built entirely in SwiftUI with zero external dependencies, it uses SVG path parsing for precise muscle rendering and offers both SwiftUI and UIKit interfaces.
TOSegmentedControl is an iOS UI library that reimplements the modern UISegmentedControl appearance from iOS 13+ for backward compatibility with older iOS versions (back to iOS 9). The library consists of a main control class (TOSegmentedControl) that manages the overall appearance and behavior, and a segment class (TOSegmentedControlSegment) that represents individual items. It supports both text and image segments, dynamic addition/removal of items, configurable appearance (colors, fonts, corner radius), and special features like 'reversible' segments that toggle direction when tapped. The implementation includes sophisticated touch handling with spring-based animations, custom layout management, and proper adaptation to system appearance changes (dark/light mode).
This repository is the DGCharts framework (formerly Charts), a mature, open-source charting library for Apple platforms (iOS, tvOS, macOS). It is a direct port of the popular MPAndroidChart library, providing nearly identical API for cross-platform consistency. The library offers eight primary chart types: Line, Bar, Pie, Scatter, CandleStick, Bubble, Radar, and Combined (overlaying multiple chart types). It supports rich customization including dual axes, animations, legends, highlighters, limit lines, markers, and value formatters. The codebase is structured with protocol-oriented design separating views, renderers, data models, and formatters. It includes comprehensive demo applications for iOS (Swift and Objective-C) and macOS, as well as playgrounds and snapshot-based unit tests. The library is distributed via CocoaPods, Carthage, and Swift Package Manager, and requires iOS 12+, tvOS 12+, or macOS 10.13+. While the core functionality is well-established, the codebase shows some technical debt including deprecated API methods, TODOs for Swift collection conformance, and a large number of demo controllers that duplicate boilerplate. Overall, it is a production-grade visualization library with a strong architecture and active maintenance.
This is a comprehensive server monitoring and management platform called ServerBox (Flutter Server Box). It consists of a cross-platform Flutter mobile/desktop app, a Rust-based agent (monitor) that collects system metrics and exposes a REST/WebSocket API, and a Svelte web panel. The system supports SSH terminal sessions, SFTP file management, container management, virtual machine management (Proxmox VE and libvirt), BMC/Redfish power and sensor monitoring, firewall management (ufw/firewalld), cron, systemd/OpenRC services, process management, benchmark execution, custom commands, and push notifications. The architecture is heavily dependent on shared Rust crates (`sbm_parser`, `sbm_virt`, `sbm_redfish`, `sbm_ffi`) that are used both by the agent and via FFI by the Flutter app. This is a production-grade, actively maintained project with extensive test coverage across all layers.
macroquad is a Rust game engine and graphics library inspired by raylib, providing a simple, immediate-mode API for 2D and 3D rendering, audio, input handling, and UI. The codebase is structured as a monolithic core library with several subcrates (particles, tiled, profiler, physics-platformer, macroquad_macro) that add specialized functionality. The architecture centers on a single-threaded game loop orchestrated by the `#[macroquad::main]` proc macro, with drawing batched via an internal OpenGL abstraction (miniquad). Key data flows include texture and font loading, immediate-mode UI widget rendering, and an experimental scene/coroutine system for game logic. The library is cross-platform (Windows, Linux, macOS, Web, Android, iOS) and emphasizes minimal dependencies and ease of use. While the core is tightly coupled, several subcrates and subsystems are well-encapsulated and demonstrate high craftsmanship.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
Episteme is a modern, cross-platform e-book and document reader built with Kotlin Multiplatform and Compose Multiplatform. It supports a wide array of formats including EPUB, PDF, MOBI, audiobooks (M4B), FB2, DOCX, ODT, PPTX, and comic archives (CBZ/CBR). The app offers a rich reading experience with paginated and vertical scroll modes, text-to-speech, ink and text annotations, OPDS catalog browsing, cloud sync via Google Drive and Firestore, AI-powered summarization, and extensive customization (themes, fonts, brightness). The codebase is organized into a shared module containing core business logic, models, and policies, with platform-specific implementations for Android (native Compose, Room, WorkManager), iOS (Swift), and Desktop (Compose Desktop, Swing interop). The architecture follows a clean separation of concerns with expect/actual abstractions for platform services, making it a strong example of production-ready KMP application design.
This repository is the core codebase for uni-app-x, a next-generation cross-platform mobile development framework. Unlike the traditional WebView-based uni-app, this version utilizes UTS (Uni-app TypeScript) to compile directly to native code (Swift/Kotlin/ArkTS) for iOS, Android, and HarmonyOS, alongside Web and Mini-program support. The architecture is a monorepo structure with a plugin-based system (`uni_modules`) that allows modular distribution of native SDKs and cloud functions. It bridges JavaScript/TypeScript logic with native OS capabilities through a custom runtime engine and UTS compiler, enabling high-performance native rendering and hardware access. The system operates as a full-stack framework, including a CLI for project scaffolding, a compiler pipeline (Vite/Webpack integration), and a serverless cloud backend (`uniCloud`) for authentication, payments, and data management. Key data flows involve client-side code compilation into platform-specific binaries, communication via a native bridge (JSBridge/UTS), and serverless function execution on cloud providers (Aliyun, Tencent, Alipay). The framework relies heavily on embedded native dependencies (Lottie, IJKPlayer, TencentLBS) and maintains a complex plugin ecosystem to abstract platform differences. While the codebase demonstrates high craftsmanship in native rendering engines and plugin architecture, it carries significant maintenance overhead due to platform fragmentation and the need to keep embedded native SDKs synchronized with OS updates. The UTS language and compiler are custom-built, introducing a layer of technical debt and drift risk as the ecosystem evolves. The project is actively maintained with frequent updates to SDKs and compiler stability, but the complexity of supporting multiple platforms simultaneously creates a medium level of technical drift.
objection is a runtime mobile exploration toolkit powered by Frida, designed for security testing of iOS and Android applications without requiring jailbreak or root access. It provides an interactive REPL (objection explore) that lets security researchers bypass SSL pinning, dump keychain/keystore data, monitor cryptographic operations, inspect heap memory, hook methods, and bypass jailbreak/root detection — all by injecting a Frida agent into the target process. Architecture: The Python backend handles CLI commands, device state management, and patching (injecting Frida gadget into IPA/APK files). The TypeScript agent running inside the mobile app exports RPC methods for platform-specific features (Android: hooking, keystore, intents; iOS: keychain, crypto, biometrics). Communication happens over Frida's bi-directional transport. A Flask API server exposes RPC and script endpoints for remote control. The system uses a centralized state layer (connection, device, jobs) and a plugin system for extensibility. Key entry points: 'objection explore' (REPL), 'objection patchapk'/'objection patchipa' (binary patching), 'objection api' (API server), and the agent entry point in 'agent/src/index.ts'. External dependencies include frida, frida-tools, frida-fs, frida-screenshot, Flask, apktool, and GitHub API for gadget downloads. The codebase is well-structured for mobile security automation but shows some drift with deprecated CLI flags, Python 2 compatibility checks, and TODOs for advanced hooking targets.
Onsen UI is a comprehensive mobile UI framework for building hybrid mobile apps and progressive web apps (PWAs) with native-like interfaces. The repository is a monorepo containing a core library built on Web Components, CSS components with iOS and Material Design theming, and official bindings for React, Vue 2, Vue 3, Angular 2+, and legacy AngularJS. The core defines custom HTML elements (e.g., `<ons-navigator>`, `<ons-tabbar>`, `<ons-dialog>`) that encapsulate mobile-specific UI patterns such as navigation stacks, tab bars, side menus, pull-to-refresh, lazy lists, and various form controls. The CSS component library provides a consistent, themable styling layer via CSS custom properties and BEM-like modifier classes. Framework bindings wrap these core elements for seamless integration with modern frontend frameworks. The repository also includes example applications, a CSS component previewer, and extensive documentation schemas. While the framework is mature and feature-rich, it shows signs of technical drift with deprecated APIs, multiple legacy binding packages, and a complex build infrastructure. It is actively maintained but appears to be in a stabilization phase rather than rapid development.
Hippy is a cross-platform mobile application framework developed by Tencent that enables developers to build native mobile apps using JavaScript with React or Vue. It provides a JS driver layer that communicates with native renderers on Android, iOS, OpenHarmony, and Web via a bridge system. The architecture is modular: a DOM layer manages the virtual tree and layout (using Taitank or Yoga), native renderers create platform-specific UI components, and a virtual file system (VFS) handles resource loading. The framework includes a full devtools backend implementing Chrome DevTools Protocol for debugging, performance monitoring, and DOM inspection. Key entry points include the JS bootstrap (hippy.js), native engine managers (HippyEngine on Android, HippyBridge on iOS), and the JS framework adapters (hippy-react, hippy-vue, hippy-vue-next). External dependencies include V8, Hermes, JSC, or JSH JavaScript engines, and platform-specific SDKs (AndroidX, UIKit, ArkUI). The codebase is large and actively maintained, with multiple renderer implementations and both Vue 2 and Vue 3 support, though some duplication and deprecated code exist.
This repository is an educational companion to the book 'Programming with 64-Bit ARM Assembly Language', adapted for Apple Silicon (ARM64 macOS, iOS, watchOS, tvOS). It contains 16 chapters of progressively complex assembly examples, covering system calls, memory addressing, functions, floating-point, NEON, and optimization. The code demonstrates key differences between Linux and Darwin (Apple) ABIs, such as syscall numbers, addressing modes (ADRP/ADD vs LDR =symbol), and variadic function calling conventions. It includes reusable debug macros (printReg, printStr) for register inspection, file I/O macros, and a toupper function callable from C, Python, and Swift. The project also features an Xcode SwiftUI app that integrates assembly code across multiple Apple platforms. The repository is well-maintained and actively used as a reference for Apple Silicon assembly development.
StaSh is a full-featured interactive shell for iOS Pythonista, also running on desktop via Tkinter. It provides a Bash-like environment with command parsing, auto-completion, aliases, environment variables, pipes, redirects, job control, command history, and virtual keys. The architecture is modular: a core runtime (ShRuntime) manages execution, threading, and state; a parser/expander handles shell grammar; a terminal emulation buffer (ShChar/ShSequentialScreen) renders output; and multiple UI backends (Pythonista native, Tkinter, stub) abstract the display layer. The shell ships with 30+ built-in commands (pip, git, ssh, scp, sqlite, ping, etc.), a filesystem interface (FSI) for local, FTP, Dropbox, and zip mounts, a monkey-patching framework for iOS compatibility, and a package manager with Pythonista-specific workarounds. The codebase is well-structured with clear separation of concerns, but shows signs of technical drift: Python 2 remnants, some deprecated library usage (e.g., telnetlib), incomplete Python 3 porting, and fragile workarounds for iOS limitations. It is not a data research project.
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.
This repository provides flutter-webrtc, a Flutter plugin that wraps native WebRTC SDKs (Android, iOS, maccOS, Windowws, Linux, embedded Linux, and Web) to enable real-time audio/video communication, screen shaning, data channels, and end-to-end encryption. The architecture follows a common Dart interface with platform-specific implementations using method channels, event channels, and texture registries. Key entry points include the Dart factory classes (RTCFactoryNative/Web) and native plugin handlers (FlutterWebRTCPlugin on each platform). The plugin exposes a comprehensive WebRTC API including getUseMedia, peer connections, tranceivers, simulcast, stats, and E2EE via frame cryptors. It is actively maintained with regular commits and issue triage, but exhibits code duplication across platforms and some fragile patterns (reflection, monoilithic method handlers).
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.
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.
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.