This repository is a web application for generating privacy policies and terms of service for mobile and web apps. Built with Vue.js 3 and Bulma CSS, it features an 8-step wizard interface where users configure policy type (Simple, No Tracking, GDPR), app details, platforms, features, and third-party services. The application generates customized HTML/Markdown policies deployable to Flycricket or downloadable directly. It includes a PWA with service worker for offline support, internationalization (English/German), and a persistent theme toggle. The architecture centers on Vue composables for state management (app state, wizard navigation, content generation) and a Go-based build system that processes Go templates, compiles Less to CSS, and minifies assets. Key reusable patterns include modular template mixins, a flexible modal system, and utility functions for DOM manipulation. An ancillary tool in `tools/reviews-page-generator` fetches GitHub issue comments to generate a static testimonials page. The codebase demonstrates strong engineering practices: comprehensive Playwright test suite, golden HTML regression tests, dependency management via Go modules and package.json, and automated deployment workflows. While the custom build pipeline adds slight complexity, the separation of concerns and reusable components indicate maintainable, craftsmanship-driven development.
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.
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.
Anytype for iOS is a full-featured, offline-first knowledge management and collaboration application. It provides a block-based editor for notes, documents, and databases (sets/collections), along with chat, spaces, widgets, and membership management. The architecture follows MVVM with a coordinator pattern, heavily leveraging SwiftUI for modern UI and UIKit for legacy editor components. Communication with the backend (middleware) is via protobuf-defined commands and events, with real-time subscription-based data synchronization. Dependency injection is handled through the Factory library, and the codebase is modular with separate packages for services, design system, core utilities, and generated protobuf models. The app supports iOS 17+ and uses Swift 6 concurrency features extensively.
This repository contains the iOS client for the ntfy.sh notification service. It is a SwiftUI-based application that allows users to subscribe to topics for receiving push notifications, manage subscriptions, view notifications with attachments, and configure settings. The architecture follows a pattern similar to MVVM using ObservableObjects for state management, with Core Data for persistence and a Notification Service Extension for processing incoming notifications. Key features include Firebase Cloud Messaging integration, attachment handling (download, preview, share, save), critical alerts support, and background polling for notification synchronization. The app supports both the default ntfy.sh server and self-hosted instances.
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.
This repository contains the public-facing source code for Draw Things, a production-grade AI image and video generation application for macOS/iOS/Linux. The codebase implements a comprehensive suite of diffusion models (Stable Diffusion, FLUX, HiDream, Qwen, MiniMax, etc.), samplers, LoRA training, model conversion, and a gRPC-based distributed inference server. It is written primarily in Swift, using Bazel for builds, and includes extensive use of FlatBuffers for data serialization, SQLite for persistence, and a custom neural network compiler (NNC) for on-device inference. The architecture is modular, with separate libraries for tokenization (CLIP, Tiktoken, SentencePiece), model zoos (downloadable model specifications), image generation pipelines, and cloud authentication. The repository also includes CLI tools (draw-things-cli, gRPCServerCLI, model converters) and server management scripts for deploying GPU-backed inference services with Tailscale, Envoy, and Docker. While the core application is a consumer-facing app, the codebase also contains research-grade components such as instruction count estimators for performance profiling, formal verification tools (Z3, Lean), and web search integration with browser fallback. The code is well-structured with many reusable patterns, though it carries some maintenance overhead from vendored dependencies and generated code.
Everywhere is an iOS VPN/proxy client that lets users choose between three open-source proxy cores—Xray, sing-box, and mihomo—to route device traffic through custom configurations. The app uses Apple's Network Extension framework (NEPacketTunnelProvider) to establish a VPN tunnel, with the selected core executed inside the tunnel process. Configurations can be imported, subscribed to, or edited directly within a SwiftUI interface, and a bundled web dashboard (zashboard) provides real-time monitoring and control via the Clash API.
This repository is a collection of iOS application projects that recreate various UI designs from sources like Instagram, Dribbble, and Facebook. Each project is a self-contained iOS app implemented in either Swift (UIKit) or SwiftUI, demonstrating how to translate specific designs into functional code. The repository serves as an educational resource for iOS developers looking to learn practical UI implementation techniques. The project follows a clear organizational structure where each episode resides in its own folder containing a downloadable ZIP file with the complete source code. Projects cover a wide range of UI concepts including onboarding flows, social media interfaces, messaging apps, music players, and more. Both UIKit and SwiftUI implementations are showcased, reflecting the evolution of iOS development practices. While the actual implementation details are contained within the ZIP archives and cannot be directly inspected in this repository view, the consistent naming convention, clear documentation in README.md, and regular maintenance indicate a well-organized educational resource. The repository appears to be actively maintained with recent commits and covers contemporary iOS development topics.
Bark is a native iOS application that turns APNs push notifications into a self-hostable, customizable notification delivery system. It is not a data or research project; it is a polished consumer iOS app with a companion widget, notification service extension, and App Intents. In production, the app maintains a device registration key per user, listens for remote notifications via Apple Push Notification service, and enriches incoming payloads through a chain of processors in the Notification Service Extension: decrypting AES-encrypted bodies (CBC/ECB/GCM with CryptoSwift), rendering Markdown, setting badges, auto-copying text, archiving to Realm, muting groups, triggering call interruptions, and attaching images/icons. The main app provides a history list with group/section rendering, server management (defaults to api.day.app but supports custom self-hosted servers), QR-code server import, encryption settings, archive retention controls, sound selection, and a modern home screen demonstrating usage via curl-like examples. A WidgetKit timeline widget shows recent messages from a shared JSON snapshot, and Siri/Shortcuts intents can trigger pushes to the current or another device. The architecture follows a reactive MVVM pattern using RxSwift/RxCocoa throughout, with Realm as the local persistence layer shared across app and extensions via an App Group container. The project targets iOS 15+ with five Xcode targets (main app, notification service extension, notification content extension, widget, tests) and is distributed via the App Store and TestFlight through fastlane and GitHub Actions.
This repository is a Chinese-language translation and expansion of the Learn wgpu tutorial series, teaching the wgpu Rust implementation of the WebGPU graphics API through a Cargo workspace of ~25 runnable example crates. The curriculum progresses from window/surface setup (tutorial1-2), render pipelines and buffers (tutorial3-4), textures/uniforms/instancing/depth (tutorial5-8), through OBJ model loading, Blinn-Phong lighting, normal mapping, camera control, compute-shader terrain generation, HDR rendering, and particle systems. Each example is a small but complete winit application that runs natively and as WebAssembly via wasm-bindgen, sharing a common utils crate that provides the WgpuAppAction lifecycle trait, node-based render abstractions (ViewNode, ComputeNode, BufferlessFullscreenNode), and buffer/bind-group helpers. A VitePress documentation site embeds live WASM demos of the examples, and showcase crates demonstrate a Pong game, offscreen GIF encoding, multithreaded model loading, and compute-shader tangent generation. Although primarily a tutorial codebase, it is genuinely hybrid: it doubles as a deployable documentation site and a reference implementation of modern wgpu patterns.
This is a cross-platform Flutter application that serves as an unofficial client for the Pixiv illustration and novel platform. It provides a full-featured browsing experience including OAuth login, search, ranking, bookmarks, following, recommendations, comments, and a download manager with offline viewing. The architecture follows a standard Flutter app structure with custom state management (StateController), a centralized network layer using Dio to interact with Pixiv's private API, and local SQLite storage for caching images, download history, and settings. The UI is built with Fluent UI for a desktop-native look on Windows, macOS, and Linux, with platform-specific adaptations for Android and iOS. The codebase demonstrates moderate craftsmanship with reusable components like a generic cache manager, custom image provider with retry logic, and utility classes for debouncing and periodic tasks. However, it has some maintenance risks including hardcoded API credentials, reliance on undocumented Pixiv API endpoints, and a few code quality issues such as fall-through bugs in keyboard handling and non-localized strings.
Watt Toolkit (Steam++) is a cross-platform desktop application that serves as a multi-functional game toolbox primarily for Steam users. The system provides network acceleration via a local reverse proxy (YARP-based) with HTTPS interception, DNS analysis, and multiple proxy modes (Hosts, System, PAC, VPN, DNS intercept). It includes plugins for Steam account switching, two-factor authenticator management (import/export/recovery), game library management, ArchiSteamFarm integration for card farming, and game tools. The architecture is a modular plugin system built with Avalonia UI, .NET, and ReactiveUI, using a multi-process IPC model for privilege separation. External dependencies include WinDivert for Windows packet interception, XunYou SDK for game acceleration, and ArchiSteamFarm for automated Steam actions. The codebase demonstrates a complex but functional architecture with significant platform-specific code and some areas of technical debt.