AppFlowy

AppFlowy is an open-source, cross-platform collaborative workspace designed as a privacy-first alternative to Notion. It unifies documents, databases, wikis, and project management into a single interface with built-in AI that runs entirely on your own hardware — no data leaves your machine unless you choose otherwise.

Built with Flutter for native cross-platform UI and Rust for high-performance backend operations, AppFlowy runs on macOS, Windows, Linux, iOS, and Android from a single codebase. It supports real-time collaboration via CRDT-based synchronization and works fully offline, syncing seamlessly when connectivity is restored.

The AI capabilities go beyond simple integrations: AppFlowy embeds local LLM inference (Mistral 7B, Llama 3) directly into the native app, with retrieval-augmented generation, conversation memory, AI transcription, and meeting notes — all running on-device. It also supports MCP (Model Context Protocol) to connect AI agents to external tools and databases from within the workspace.

Self-hosters can deploy AppFlowy Cloud using Docker and retain 100% control over their data, while teams can choose AppFlowy’s managed cloud for a zero-ops experience. With 72,000+ GitHub stars and releases every few weeks, AppFlowy is one of the most actively developed open-source productivity platforms available.

What You Get

• Local AI with On-Device LLMs - Run Mistral 7B and Llama 3 directly in the app via a Rust inference engine, enabling AI writing, summarization, and chat without sending data to any cloud service.
• CRDT-Powered Collaboration - Real-time conflict-free collaborative editing using CRDT technology lets multiple users edit simultaneously with automatic conflict resolution, even across offline periods.
• Rich Document Editor - A block-based editor supporting text, headings, images, code blocks, Mermaid diagrams, embeds (Google Drive, video, files), and callouts — all in a distraction-free interface.
• Flexible Database Views - Build databases and visualize them as Grid, Kanban board, Gallery, Calendar, List, Chart, or Feed views; with filters, sorting, grouping, relations, rollups, and formula fields.
• AI Meeting Notes & Transcription - Record or upload audio for automatic transcription with speaker identification, then generate structured meeting summaries and action items using AI.
• MCP Tool Integration - Connect the built-in AI to external tools, APIs, and services via Model Context Protocol support, extending AI capabilities beyond the workspace itself.
• Self-Hosted with Docker - Deploy the full AppFlowy Cloud backend using the provided Docker Compose setup, retaining complete control over data storage, user management, and access.
• Cross-Platform Native Performance - A single Flutter + Rust codebase delivers native-speed performance on macOS, Windows, Linux, iOS, and Android without Electron overhead.
• Semantic Search with Vector Embeddings - Full-text and semantic search powered by local vector embeddings stored in SQLite, enabling AI-assisted discovery of related content across your workspace.

Common Use Cases

• Privacy-first team knowledge base - An engineering team self-hosts AppFlowy on their own server to maintain internal documentation, architecture decisions, and runbooks with no data leaving their infrastructure.
• AI-assisted personal productivity - A researcher uses on-device Llama 3 to summarize papers, extract key points from notes, and auto-complete database fields without exposing sensitive material to cloud AI providers.
• Startup project management - A product team uses linked databases across Kanban, Grid, and Calendar views to track features, sprints, and deadlines, with AI generating weekly status summaries from task data.
• Meeting-driven team workflow - Remote teams record standups and client calls, use AppFlowy’s AI transcription with speaker identification to generate action items, then link them directly to project databases.
• Developer wiki with offline access - A distributed open-source project hosts its contribution guides and architecture docs in AppFlowy, allowing contributors to work fully offline and sync when connected.

Under The Hood

Architecture AppFlowy employs a rigorous separation between a Flutter-based cross-platform UI layer and a Rust core engine communicating via FFI with Protocol Buffers for typed serialization. The architecture follows an event-driven dispatch model: Flutter sends strongly-typed events through a custom message bus (lib-dispatch), which routes them to Rust handler modules organized by domain — documents, databases, AI, folders, storage, and user management. Each domain exposes a public trait crate (e.g., flowy-database-pub) that decouples interface from implementation, enabling pluggable server backends (local SQLite and AppFlowy Cloud) via trait objects. Flutter-side state management uses BLoC throughout, providing predictable unidirectional data flow across more than 700 BLoC consumers. The startup system uses get_it for dependency injection with ordered task initialization. This layered design allows UI and backend to evolve independently, though the FFI boundary and dual-language build pipeline raise the contributor entry barrier considerably.

Tech Stack The frontend is Flutter 3.27+ with Dart, targeting macOS, Windows, Linux, iOS, and Android from one codebase. The backend engine is Rust, compiled per platform via cargo-make and cargo-lipo for multi-architecture iOS support. Data persistence uses SQLite through flowy-sqlite, with flowy-sqlite-vec adding vector embedding storage for semantic search directly in the local database. Real-time collaboration uses CRDTs via the collab crate integrated through collab-integrate. AI runs through a local inference stack (flowy-ai/local_ai) supporting Mistral and Llama models, complemented by MCP (Model Context Protocol) for connecting AI to external tools. CI/CD combines Codemagic for Apple platform builds (iOS, macOS), GitHub Actions for Flutter and Rust, and a Docker Compose deployment path for self-hosted AppFlowy Cloud.

Code Quality The codebase demonstrates genuine investment in testing: 94 Dart unit and widget test files alongside 60 Rust test modules, plus a nine-runner parallel integration test suite for desktop. Rust modules use structured error types via thiserror with anyhow for propagation, avoiding silent failures. The Flutter side follows BLoC conventions consistently, and formatting is enforced with rustfmt.toml and Flutter’s analysis_options.yaml. However, the build toolchain demands significant setup — cargo-make, duckscript, cargo-lipo, and Protobuf codegen are all prerequisites — which creates friction for new contributors. Integration tests require platform emulators, limiting local iteration speed. Overall quality is solid for a project of this scale, though build complexity is the clearest pain point.

What Makes It Unique AppFlowy’s most technically distinctive contribution is running full AI inference natively — not just wrapping a local API, but embedding LLM chains with retrieval augmentation, streaming responses, conversation memory, and AI transcription directly inside the native Rust engine. The recently added MCP (Model Context Protocol) support makes AppFlowy a first-class MCP client, connecting workspace AI to external tools and databases without leaving the app. CRDT-based collaboration via the custom collab crate enables conflict-free offline editing and synchronization without server round-trips — an unusually high-quality implementation in open-source productivity software. The vector embedding layer built directly into SQLite (flowy-sqlite-vec) enables semantic search across workspace content without any external vector database, a rare capability for a fully self-hostable tool.

Self-Hosting

AppFlowy is released under the GNU Affero General Public License v3.0 (AGPLv3). This is a strong copyleft license: you can use, modify, and self-host AppFlowy freely for any purpose, including commercial use, but if you distribute a modified version or run it as a network service that others access, you must release your modifications under the same AGPLv3 terms. For most self-hosters running AppFlowy internally for their own team, the copyleft requirement has no practical effect — it only applies if you build a product on top of AppFlowy and make it available to others.

Operationally, self-hosting AppFlowy means deploying AppFlowy Cloud via the provided Docker Compose configuration, which includes the backend API server, a PostgreSQL database, and optional object storage. You are responsible for server provisioning, database backups, TLS termination, user authentication setup, and keeping the deployment updated as new versions release. The project ships frequent releases — roughly every two weeks — so staying current requires an active maintenance posture. The build complexity of the client apps themselves (Rust + Flutter + cargo-make toolchain) means most self-hosters will use pre-built binaries from GitHub Releases rather than compiling from source.

Compared to the managed AppFlowy Cloud service, self-hosters give up zero-ops convenience, managed backups, and guaranteed uptime SLAs. The managed cloud also offers a team collaboration tier with more integrated onboarding. Community support is available through Discord and GitHub Issues, but there is no enterprise support contract available for self-hosted deployments. Teams that need formal SLAs, dedicated support, or managed infrastructure should evaluate the hosted AppFlowy Cloud plan before committing to self-hosting.