AFFiNE puts docs, whiteboard and databases on one local-first canvas, with a canary release train and an unfinished plugin story

Docs and whiteboard share one edgeless canvas

The central idea in AFFiNE is that a document and a whiteboard are the same surface. The project calls this an edgeless canvas: any building block can be placed on it, including rich text, sticky notes, embedded web pages, multi-view databases, linked pages, shapes and slides. The tagline on the repository says docs, canvas and tables are hyper-merged, a pun on the word affine itself, pronounced like a-fine.

In practice this means you do not choose between a page app and a whiteboard app before you start writing. A meeting note can grow into a diagram, and a database view can sit next to freehand shapes on the same board. The project frames itself as an all-in-one workspace covering wiki, knowledge management, presentation and digital assets, and as an alternative to Notion and Miro. The acknowledgement section names the ideas it borrows: blocks from Quip and Notion, Kanban from Trello, programmable datasheets from Airtable and Miro, the edgeless whiteboard from Miro and Whimsical, and object-based tags from Remote and Capacities.

Local-first storage with real-time sync layered on top

AFFiNE describes itself as local-first: you own your data on your disk, regardless of the cloud. Sync and real-time collaboration are added on top, working across the web app and the cross-platform clients. That ordering matters for anyone who has lost access to a hosted workspace before. The copy on disk is the primary one, and the server is a way to share it.

The source tree shows how much of this sits below the TypeScript layer. The Cargo workspace includes crates under packages/frontend/native named nbstore, schema and sqlite_v1, plus packages/frontend/mobile-native and packages/backend/native. These are bridged into JavaScript through napi 3.7.0 with the napi9 feature set. The shared Rust dependencies also include aes-gcm and hkdf, image decoding for bmp, gif, jpeg, png and webp, and media parsers such as mp4parse and matroska, alongside coreaudio-rs and cpal for audio on the native side. The Rust crates use the 2024 edition with resolver 3, and a rust-toolchain.toml at the root pins the compiler for builds.

Plugins and third-party blocks are still announced as coming soon

The acknowledgement section makes a pointed argument against the tools AFFiNE draws from: they are not open source, and they lack a plugin system like the one VS Code offers contributors. AFFiNE wants to go one step further. Yet the self-hosting paragraph says plainly that a plugin community and third-party blocks are coming soon, and points readers to BlockSuite, the editor framework that lives in the blocksuite directory of this monorepo, for more traction on that front.

The consequence is concrete. If your plan depends on adding a custom block type or wiring AFFiNE into an internal system through an extension API, there is no published plugin route to rely on yet. What you can do today is what the project offers explicitly: manage, self-host, fork and build your own AFFiNE. That puts customization in the territory of maintaining a fork of a large TypeScript and Rust monorepo, with all the merge work that implies each time upstream moves. Teams that want Notion-style integrations out of the box should weigh that before migrating.

Two license files and a license field GitHub cannot resolve

GitHub reports the repository license as NOASSERTION, meaning it could not match the licensing to a single standard license. The root of the repository contains two files, LICENSE and LICENSE-MIT, while the monorepo package.json declares MIT. Those three signals do not line up into one simple answer, and that is the reason to read both license files directly instead of relying on the badge or the package metadata.

This matters most for organizations planning to self-host AFFiNE for many users, embed parts of it in a product, or redistribute a fork. Which directories fall under which license is something to confirm from LICENSE and LICENSE-MIT themselves. Contributors face a second requirement: every committer must sign the Contributor License Agreement before a pull request can be merged, enforced by the license/cla check on each PR, with the full text in .github/CLA.md. Signing takes under a minute with a GitHub account, but an unsigned co-author on a commit will block the merge.

Every recent GitHub release is a canary build

The default branch of the repository is canary, not main, and the release tags follow it. The three most recent GitHub releases are v2026.10.25-canary.907, v2026.10.26-canary.915 and v2026.10.27-canary.909, published on consecutive days. The last push to the repository was on November 2, 2026, so the project is shipping code at a daily pace. Meanwhile the root package.json carries a separate version number, 0.27.5, which does not resemble the date-based canary tags.

The practical consequence is that anyone who goes to the GitHub releases page looking for an installer lands on canary builds first. Canary is the branch where changes arrive before they are settled, so for a personal knowledge base that holds years of notes, the safer route is the download page at affine.pro/download that the repository links from its header. Anyone filing a bug should note which channel and which build tag they are on, because a canary from one day can differ from the next.

Source builds require Node 22 and nothing newer

The package.json engines field reads node >=22.12.0 <23.0.0. That upper bound is strict: a machine on Node 23 or Node 24 falls outside the declared range, so contributors need a version manager set to the 22 line. A .nvmrc file sits at the root for that purpose, and the repository uses Yarn, with .yarnrc.yml and a .yarn directory checked in.

The workspaces are wide: the root, everything under blocksuite, packages/*/*, the frontend apps, tools, docs/reference, type packages and tests. All top-level commands go through a single entry script. The affine and af scripts both run r affine.ts, dev runs yarn affine dev, and build runs yarn affine build. The postinstall hook runs yarn affine init and then husky, so a plain install already executes project setup code. Linting uses oxlint with warnings denied and oxfmt for formatting, tests run on vitest, and typecheck runs tsc -b over tsconfig.json. Because the Rust crates are part of the build, a working Rust toolchain matching rust-toolchain.toml is needed alongside Node.

Self-hosting is documented outside the repository

AFFiNE presents self-hosting as a core freedom, but the instructions for it live at docs.affine.pro/self-host-affine rather than in the repository front page. The repository itself carries the pieces a deployment draws on: a .docker directory, a .devcontainer setup, a render.yaml with a .render directory for Render deployments, and a .codesandbox configuration. The backend has its own native Rust crate under packages/backend/native, and the dependency metadata marks @prisma/client and @prisma/engines as packages that must run their build steps, which points to Prisma as the database access layer on the server side.

For evaluation, there is a hosted live demo at app.affine.pro, which lets you try the canvas before deciding whether to run your own server. For an organization, the order of work is to try the demo, read the self-hosting guide on docs.affine.pro, and then decide whether the local-first clients alone are enough or whether a server is needed for real-time collaboration across a team.

AFFiNE AI is described by task, not by model

The feature list pitches AFFiNE AI as a multimodal partner: writing up a work report, turning an outline into presentable slides, summarizing an article into a structured mind map, sorting a job plan and backlog, and drawing and coding prototype apps and web pages from a single prompt. The Canvas AI blog post linked from the same paragraph covers generating mind maps for brainstorming.

What the feature list does not say is which model performs this work or where a request is processed. The Cargo workspace does pull in crates named llm_adapter and llm_runtime, both with default features turned off, and memory-indexer, so there is language model code in the native layer. For a project that calls itself privacy-focused and local-first, this is the question a careful user should answer before turning AI on for sensitive notes: does a given request leave the machine, and under whose account? The AI page at affine.pro/ai is the place to check, and self-hosters should confirm how their own server handles AI configuration.

Editorial conclusion

AFFiNE fits people and teams who want docs, whiteboard and databases on one canvas with their data kept on their own disk, and who are willing to self-host or use the official clients. It does not fit anyone who needs a plugin ecosystem today, since plugins and third-party blocks are still announced as coming soon. Before adopting it in a company, read both LICENSE and LICENSE-MIT, confirm which build channel you are installing, and check where AFFiNE AI requests are processed.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes