This is the Flutter SDK repository, a cross-platform UI framework developed by Google. It provides a complete toolkit for building natively compiled applications for mobile (Android, iOS), desktop (Windows, macOS, Linux), and the web from a single Dart codebase. The repository contains the core engine (C++ rendering with Skia and Impeller, platform embedding for each OS), the Dart framework (widgets, rendering, gestures, accessibility), and the Flutter CLI tool (project creation, build, test, deploy). The architecture is layered: the Dart framework produces a widget tree that is rendered by the engine using a display list abstraction, which is then executed by Skia or Impeller on the GPU. Platform channels enable native interop. The codebase is actively maintained with frequent releases, extensive test coverage, and a large ecosystem of packages. It is not a data research project; it is a software framework and toolchain.
Appwrite is an open-source backend-as-a-service (BaaS) platform that provides a comprehensive set of APIs for authentication, databases, storage, serverless functions, messaging, realtime, and more. The codebase is a hybrid monolithic-microservice architecture: a central PHP application (using the Swoole coroutine-based HTTP server) handles REST, GraphQL, and WebSocket requests, while background workers (over 20 types) process asynchronous tasks such as email delivery, function execution, database migrations, and usage analytics. The platform supports multiple database backends (MariaDB, MongoDB, PostgreSQL, ClickHouse) and a variety of messaging providers (SMS, email, push). It is designed for multi-tenant deployments with per-project isolation, OAuth2 social login, and extensive API versioning. The repository also contains a large collection of reusable PHP packages (the Utopia framework) that provide caching, queueing, query building, DNS resolution, NATS messaging, HTTP client, PSR-7 implementation, and more. These packages are independently published and can be extracted for use in other projects.
FlClash is a production multi-platform proxy/VPN client that embeds and manages the mihomo (Clash.Meta) Go core. The Dart/Flutter app (Riverpod, Drift, freezed) drives a real core lifecycle: profile/subscription import and validation, proxy group and rule management, TUN/VPN on Android, system proxy on desktop, live connections/requests/DNS views, latency probing, streaming-service availability checks, and WebDAV backup/restore. The Go core exposes a method-dispatch IPC contract (updateConfig, changeProxy, getConnections, watchRoute, probe, serviceCheck, etc.) consumed through an Android cgo bridge and a desktop helper process. This is a full application, not a library or data project — no notebooks, no research pipelines. The architecture is layered: Flutter UI → manager/provider layers → core controller → framed JSON IPC → Go mihomo core. Desktop builds add a Rust privileged helper service (systemd unit / Windows SCM, Unix socket with peer-credential auth) and Rust plugins for global hotkeys, QuickJS evaluation of script-based profile overrides, and a rope-backed code editor (code_forge). Native integration plugins for system tray, window management, system proxy, and WiFi SSID are shipped as separate Dart packages with per-OS implementations in C++/Swift/Kotlin. A custom build-hook system compiles and SHA-256-fingerprints the Go core and Rust helper artifacts with file-locking to make native builds cacheable and idempotent. The codebase is unusually disciplined. Test/ subdirectories include contract tests that parse Go structs from the mihomo submodule to verify DNS-override parity, AST-parsing tests verifying every core method is dispatchable, architectural lint tests (platform layering, dead-file detection, UI tooltip enforcement, Material-icon bans), plus unit and widget tests across every layer. Concurrency is handled deliberately: priority message batching between core and UI, serial task scheduling, claim/cancel semantics for GEO/probe updates, and an Android service state machine with newest-request-wins arbitration. Release tooling generates changelogs from conventional commits and a CI pipeline produces deb/rpm/AppImage/DMG/Inno packages. Caveats: the polyglot stack (Dart, Go, Rust, Kotlin, C++, Swift) and tight coupling to mihomo internals via a git submodule make wholesale extraction impractical, and large amounts of generated code (freezed, riverpod_generator, Drift, flutter_rust_bridge) require coordinated regeneration. Browser-platform and TV branches add conditional complexity, and some UI tests assert precise pixel/animation timings that are brittle. The genuinely reusable value lives in the standalone patterns — IPC framing and batching, the rope data structure, fractional indexing, async utilities, and the fingerprinted build cache — plus the independent plugin packages themselves.
clpeak is a cross-platform synthetic micro-benchmark that measures peak achievable compute performance (FLOPS/TOPS), bandwidth, latency, and AI inference throughput across CPUs, GPUs, and NPUs. It supports eight hardware backends: OpenCL, Vulkan, CUDA, ROCm/HIP, Metal, oneAPI/SYCL, native CPU (with per-ISA dispatch), and ONNX Runtime. The tool is architected as a set of backend-specific static libraries orchestrated by a common framework, with two front-ends: a CLI tool (`clpeak`) and a Flutter desktop/mobile GUI. The GUI communicates with the native library via a C-ABI FFI bridge, streaming structured events for live display. Results are serialized to a versioned JSON schema (v3) and can be compared against baselines. The codebase is notable for its meticulous anti-optimization engineering (MAD chains, compiler barriers, calibration probes) and its protobuf-free ONNX model generator. It is a mature, actively maintained project with extensive CI coverage and packaging for multiple platforms.
FlutterFire is a large monorepo of Flutter plugins that expose Firebase services to Flutter/Dart applications. It is not an end-user application but a client-side SDK layer: each Firebase product (Auth, Firestore, Storage, Functions, Messaging, Crashlytics, Remote Config, Analytics, App Check, AI, and more) is implemented as a separately published Flutter plugin with a shared Dart API, an abstract platform interface, and native implementations for Android, iOS, macOS, Web, and Windows. The architecture relies on Pigeon-generated message channels for typed Dart-to-native communication, custom codecs for Firebase-specific types, and event channels for real-time streams such as auth state, Firestore snapshots, and storage task progress. The primary entry point is Firebase.initializeApp() via firebase_core, after which each plugin's host API methods are invoked from Dart and dispatched to the native Firebase SDKs. The repository includes extensive example apps, unit tests, and GitHub Actions CI workflows with emulator-based integration tests across platforms.
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.
Immich is a high-performance, self-hosted photo and video management platform composed of a NestJS backend server, a SvelteKit SPA frontend, a Python FastAPI machine-learning service, a Flutter mobile client (iOS/Android), a CLI tool, and a TypeScript SDK. The server orchestrates asset ingestion, metadata extraction (EXIF, OCR, facial recognition, CLIP embeddings), video transcoding (HLS), and background job processing via BullMQ/Redis, with PostgreSQL (Kysely ORM + vector extensions for smart search) as the primary data store. The ML service provides ONNX-based inference for CLIP visual/textual embeddings, face detection/recognition (InsightFace), and OCR (RapidOCR), supporting multiple hardware accelerators (CUDA, ROCm, OpenVINO, ARM NN, RKNN). The architecture uses a multi-worker process model (API, microservices, maintenance) managed by a main process that handles lifecycle and restarts. Key data flows include: mobile/web upload → asset processing pipeline → metadata extraction → ML inference → search indexing, with real-time sync via WebSocket/Redis adapter and a full incremental sync API for mobile clients. The codebase demonstrates strong engineering practices: comprehensive repository pattern with 50+ repositories, extensive medium/integration test suites, schema migrations managed via Kysely SQL tools, OpenAPI-driven SDK generation for both TypeScript and Dart, and a plugin system using Extism WASM.
EasyNode is a full-stack server management panel that provides a unified web and native interface for remote Linux server administration. The system offers SSH terminal access, SFTP file management, Docker container control, RDP remote desktop, batch script execution, and an AI agent powered by large language models. The AI agent can execute commands, read/write files, and manage hosts with configurable safety and approval workflows, including context compression and MCP tool discovery. The backend is a Node.js (Koa) monolith with an embedded NeDB database, serving a Vue 3 single-page application and a Flutter cross-platform native app (Android, iOS, macOS, Linux, Windows, HarmonyOS). The architecture is a monorepo with three main packages: server, web, and native. The server handles REST API and WebSocket connections for real-time terminal, SFTP, Docker, server monitoring, and AI agent interactions. The web frontend uses Element Plus, xterm.js, and Monaco editor, while the native app uses Riverpod, dartssh2, and re_editor. Both clients share a common feature set including authentication (RSA-encrypted passwords, MFA), proxy/jump host support, IP access control, notification integrations, and a Plus subscription model for premium capabilities. The codebase demonstrates high engineering craftsmanship with well-separated concerns, reusable utility modules (command safety classification, shell lexer, terminal highlighter, rate limiter, database wrapper), and comprehensive test coverage for both server and client components. The AI agent subsystem is particularly notable for its pluggable safety rules, context compaction, and MCP client architecture. While the monorepo is large and some duplication exists between web and native implementations, the overall design is modular and maintainable, with active CI/CD pipelines and regular releases.
super_editor is a Flutter framework for building configurable rich text editors, read-only document viewers, and chat/messaging UIs. It provides a document model based on nodes and attributed spans, a single-column layout engine, platform-specific selection/caret/toolbar controls, IME integration, and serialization to/from Markdown, HTML, and Quill Delta. The repository is a monorepo containing the core super_editor package plus supporting packages: attributed_text, super_text_layout, super_keyboard, super_editor_clipboard, and super_editor_spellcheck. It is used in production by apps such as Superlist and ClickUp, and includes example clones of Google Docs, Slack, Quill, Bear, Obsidian, Medium, and iOS Messenger.
Anx Reader is a cross-platform e-book reader application built with Flutter and Dart. It supports a wide range of formats (EPUB, MOBI, PDF, TXT, FB2, CBZ) by leveraging a forked version of the foliate-js JavaScript library as its core rendering engine, served by an embedded Dart HTTP server and displayed in a platform-abstracted WebView widget. This architecture, while functional, creates a hard dependency on a complex external JavaScript project and a Dart HTTP server for what is fundamentally a local file reader. The application follows a monolithic architecture with a strong emphasis on clean separation of concerns. It uses Riverpod for reactive state management, a service layer for business logic (AI, TTS, Sync, Translation), and a widget layer for UI composition. The codebase is notable for its extensive use of design patterns like Registry (for AI tools and dashboard tiles), Adapter (for platform-specific WebViews and TTS backends), and Repository (for AI tool data access). The Dart code itself is well-structured and demonstrates professional Flutter development practices. Beyond basic reading, it features deep AI integration (chat, summarization, content analysis via configurable providers), text-to-speech with multiple backends, WebDAV synchronization, a customizable statistics dashboard, and a full annotation system. The project is actively maintained with a sophisticated CI/CD pipeline targeting Windows, macOS, Linux, Android, iOS, and OpenHarmony. The Dart code demonstrates high craftsmanship, particularly in the AI tool framework, the dashboard tile system, and the platform abstraction layers. These components are well-isolated and could be extracted for reuse in other Dart projects. The primary risk is the tight coupling to the external foliate-js JavaScript engine and the reliance on multiple third-party AI and TTS APIs, which introduces external dependency risk and potential for API drift.
FluxDO is a cross-platform Flutter application that serves as a feature-rich third-party client for the Linux.do Discourse community. It is deployed on Android, iOS, macOS, Windows, and Linux (via Flatpak). The architecture is a modular monolith with a clean separation of concerns: data providers (Riverpod), domain services, and a large set of custom UI widgets. The networking layer is particularly sophisticated, integrating multiple HTTP adapters (Dio, cronet, rhttp), a Rust-based DoH proxy, cookie sync strategies per platform, and automated Cloudflare challenge handling. External data flows through the Discourse REST API and MessageBus WebSocket for real-time updates. The app implements its own server-side markdown rendering pipeline (discourse-cook-bundle) to reproduce Discourse's pretty-text output client-side. Custom native platform plugins for Windows (WebView2) and Linux (WPE WebKit) are heavily modified forks of flutter_inappwebview, providing zero-copy hardware-accelerated rendering. AI features integrate with multiple providers for chat, translation, and post review. The application also includes a crypto toolbox, bookmark sync, Notion integration, and a rich composer with live markdown preview. Despite being a single app, the repository contains several well-encapsulated Dart packages (common_ui, enhanced_cookie_jar, m3e_ui, paper_shaders, etc.) that are independently reusable. The codebase is actively maintained with weekly releases, but the forked webview plugins and extensive platform-specific workarounds introduce medium technical drift risk.
LocalSend is a free, open-source, cross-platform application for secure local file sharing over a local network without internet access. It supports Android, iOS, macOS, Windows, Linux, and a CLI, using a combination of Flutter for the UI and Rust for performance-critical networking, cryptography, and file transfer logic. The architecture is modular: a core Rust library (`packages/core`) implements the LocalSend protocol (v2/v3) with HTTP/HTTPS, multicast discovery, WebRTC, and TLS encryption; a Flutter app provides the graphical interface with state management via Refena (Redux-like) and i18n support for 50+ languages; and a separate CLI and WebRTC signaling server are also included. The app features device discovery, file/message transfer with progress tracking, PIN protection, checksum verification, quick-save, receive history, and a web share mode that allows browser-based downloads/uploads. The codebase demonstrates high craftsmanship with clean separation of concerns, extensive integration tests, and reusable patterns such as typed isolate communication, custom DNS resolution for IPv6 scoped addresses, and connection rate limiting.
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.
Aves is a comprehensive Android media gallery and metadata explorer application built with Flutter. It provides a feature-rich viewer for images and videos, supporting a vast array of formats including raw, HEIC, AVIF, TIFF, SVG, and motion photos. The app deeply integrates with Android's MediaStore for content access and uses platform channels to execute native metadata extraction, editing, and file operations. It includes a full-screen viewer with pinch-to-zoom, video playback with A/B repeat and slow motion, map integration with geolocation filtering, dynamic albums, vaults for secure hiding, and extensive customization of navigation, thumbnails, and the viewer experience. The architecture is modular, with separate Flutter plugin packages for model definitions, utilities, video backends, map rendering, and reporting, allowing for flavor-specific builds (Play, Izzy, Libre) that differ in third-party service integrations. The codebase is actively maintained with a strong focus on handling edge cases like malformed metadata and large files, and it demonstrates high craftsmanship in both Android native code and Flutter/Dart design.
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).
AppFlowy is an open-source AI workspace application (Notion alternative) with a Rust backend and Flutter frontend. The system provides document editing, database views (grid/board/calendar), AI chat and completion, cloud sync, collaboration, file storage, and search. It employs a modular, event-driven architecture using a custom plugin system (lib-dispatch) and protobuf code generation. The backend is split into many small crates with clear trait abstractions for cloud services, storage, and field types. Notable strengths include a well-structured database type-option system, a priority task scheduler, and support for local AI via Ollama. Weaknesses include a complex dependency graph, custom build tools, and some duplicate test infrastructure. Overall, it is a high-quality, actively developed product with strong engineering practices.
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.
Spotube is a cross-platform, open-source Spotify client built with Flutter. It provides a full-featured music player experience without requiring a Spotify Premium subscription by leveraging plugin-based metadata providers and audio sources (YouTube, Piped, Invidious, JioSaavn, etc.). The application supports local playback, playlist management, lyrics (synced and plain), downloads, scrobbling (Last.fm), remote device control via WebSocket, and extensive customization (themes, layouts, audio quality). It uses Riverpod for state management, auto_route for navigation, drift for local SQLite storage, and media_kit for audio playback. The architecture is modular with a plugin system for metadata and audio sources, making it extensible. The codebase is well-structured with reusable patterns like pagination mixins, universal image loading, and type converters. It is actively maintained with nightly builds and a large community.
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).
Butterfly is a cross-platform, open-source note-taking application built with Flutter, offering an infinite canvas for drawing, writing, and organizing notes. It supports a wide range of tools including pen, eraser, shape, text, laser, ruler, stamp, and area management, along with features like layers, pages, waypoints, backgrounds, textures, and real-time collaboration via WebSocket or Swamp protocols. The application can export to PDF, SVG, PNG, and Xournal++ formats, and integrates with WebDAV for file synchronization and backup. It is available on Android, Windows, Linux, macOS, iOS, and web platforms. The architecture follows a BLoC/Cubit pattern for state management, with a clear separation of concerns: handlers manage tool interactions, renderers draw elements on the canvas, and selections provide property editing UIs. The core data models are defined in a separate Dart package (`butterfly_api`) using freezed and json_serializable for immutable, serializable objects. The app uses a custom file system abstraction (`lw_file_system`) to support local, WebDAV, and Android SAF storage backends. Keyboard shortcuts are declaratively defined via an Action/Intent system, and the app supports embedding via a postMessage bridge for iframe integration. Key entry points include `app/lib/main.dart` for app bootstrap, `app/lib/bloc/document_bloc.dart` for central document state, and the various handler and renderer files in `app/lib/handlers/` and `app/lib/renderers/`. The application relies on external dependencies such as Flutter SDK, flutter_bloc, freezed, archive, phosphor_flutter, pdfrx, and material_leap. The codebase is actively maintained with frequent releases, extensive localization (20+ languages), and a comprehensive documentation site built with Astro/Starlight.