AFFiNE: A Local-First Notion and Miro Alternative You Can Self-Host

The problem AFFiNE targets: a wiki, a board and a database that refuse to share a page

Most teams end up with at least three tools. A wiki holds the written knowledge, a whiteboard holds the diagrams, and a spreadsheet or database tool holds the structured records. The friction is not the number of tools. It is that a paragraph written in the wiki cannot be dragged onto the board, and a row in the database cannot be embedded next to the paragraph that explains it.

AFFiNE's answer, as the README puts it, is to be an "open-source, all-in-one workspace and an operating system for all the building blocks that assemble your knowledge base". The README claims it is "one of the very few which allows you to put any building block on an edgeless canvas -- rich text, sticky notes, any embedded web pages, multi-view databases, linked pages, shapes and even slides". That is the whole pitch in one sentence: the same block objects appear in a document view and on an infinite canvas.

The intended audience is broad, and that breadth is itself a signal. The README addresses people who write reports, people who draw prototypes, and people who sort a backlog. It also names a plugin system as a future direction rather than a shipped feature, so anyone arriving because they want to extend the editor should read that line carefully.

How the block model, the Rust native layer and the monorepo fit together

The repository is a Yarn workspace monorepo with a Cargo workspace inside it. The package.json declares workspaces covering blocksuite, packages, tools, docs/reference and tests, and the root package is named @affine/monorepo at version 0.27.5. That layout tells you the editor is not a single app but a set of packages, with BlockSuite as a separately named subtree.

The Rust side is where the local-first claim gets its teeth. Cargo.toml lists members including packages/frontend/native, packages/frontend/native/nbstore, packages/frontend/native/schema, packages/frontend/native/sqlite_v1, packages/backend/native and packages/frontend/mobile-native. The dependency list includes aes-gcm, hkdf and base64 alongside sqlite-oriented crates, and napi with the async, chrono_date, error_anyhow, napi9 and serde features. Read together, that points to a native store layer exposed to the TypeScript frontend through N-API, with encrypted local persistence rather than a browser-only store.

The README describes the collaboration model as "local-first that you always own your data on your disk, in spite of the cloud", plus "real-time sync and collaborations on web and cross-platform clients". So the data flow is: edits land in the local native store first, and sync reconciles across clients. The README does not describe the sync protocol, conflict resolution, or what happens when two offline clients edit the same block. That is a real gap for anyone evaluating it as a team tool.

Installing AFFiNE from source and opening your first edgeless canvas

The README points at affine.pro/download for binaries and at docs.affine.pro/self-host-affine for self-hosting. It does not print build steps inline. The build steps come from package.json instead, and they are strict about the toolchain: the engines field requires node >=22.12.0 <23.0.0, so Node 24 will not satisfy it. The Cargo workspace pins edition 2024 and includes a rust-toolchain.toml at the repository root.

Install dependencies with Yarn. The postinstall hook runs the project's own init command and then Husky, so the first install does more than fetch packages.

yarn install

Start the development server through the affine script, which the package.json aliases as both "affine" and "af".

yarn dev

The root scripts also expose yarn build, yarn typecheck, yarn test (vitest --run) and yarn lint, which chains oxlint --deny-warnings with oxfmt --check. If you are reading the code rather than running it, yarn typecheck is the fastest way to see whether a branch is internally consistent, since it runs tsc -b over the composite tsconfig.

Once the dev server is up, the first real use is the one the README keeps returning to: create a page, then switch it to the edgeless canvas and drop a block onto it. The README's list of what can live on that canvas is rich text, sticky notes, embedded web pages, multi-view databases, linked pages, shapes and slides. Try a database block and a sticky note on the same canvas. That single test tells you whether the merged model is the reason you came.

Where AFFiNE breaks down: canary releases, missing rollback docs and no plugin system yet

The release history is the first limitation. The three most recent releases are all canary builds: v2026.8.28-canary.1251, v2026.8.27-canary.1230 and v2026.8.26-canary.914, published on 2026-08-28, 2026-08-27 and 2026-08-26 respectively. The default branch is canary. The last push to the repository was on 2026-08-28. Nothing here is a long-lived stable tag with a backport policy, so a self-hoster who pins a canary build and later needs to roll back has no documented path. The README does not document rollback, and it does not document a migration story between schema versions, even though the Cargo workspace contains a sqlite_v1 crate whose name implies versioning exists.

The plugin system is the second gap, and it is stated plainly. The README says "Plugin community and third-party blocks are coming soon", then points readers at Blocksuite for more. Anyone choosing AFFiNE because they want to write extensions the way they would for an editor with a mature plugin API is choosing it for a feature the README places in the future tense.

The third issue is scope. AFFiNE AI is described in the README with a list of tasks: turning an outline into slides, summarizing an article into a mindmap, sorting a job plan, and generating prototype apps from one prompt. That is a hosted product surface linked to affine.pro/ai. If your reason for self-hosting is to keep content off third-party services, an AI feature that calls out to a service is a decision you have to make separately, and the README does not explain what data leaves the machine.

AFFiNE versus Notion: same block idea, different ownership model

The README names its influences directly. It credits "Quip & Notion with their great concept of everything is a block", Trello for Kanban, Airtable and Miro for no-code programmable datasheets, and Miro and Whimsical for the edgeless whiteboard. It then makes a specific criticism: those apps "are not open source, nor do they have a plugin system like Vscode for contributors to customize".

That is the real difference in approach. Notion is a hosted service where the block model lives on Notion's servers and the client is a view onto it. AFFiNE inverts that: the README's local-first claim means the block data sits on your disk, and the cloud is a sync target rather than the source of truth. The Cargo workspace, with its native store crates and N-API bindings, is the mechanism behind that inversion.

The trade-off is operational. With Notion, someone else runs the database, handles backups and ships migrations. With AFFiNE self-hosted, you inherit the sqlite_v1 schema, the canary release cadence and the absence of documented rollback. You gain the ability to fork, self-host and build your own, which the README lists as a feature. You also gain the obligation that comes with it.

Licensing and the cost of tracking a canary branch

The repository root contains both LICENSE and LICENSE-MIT, and package.json declares "license": "MIT" for the @affine/monorepo package. That is not the same as the whole repository being MIT. The README's own description does not state a licence, and the presence of two licence files at the root means you should read both before redistributing anything, particularly if you plan to ship a modified build. This is a factual observation about the files present, not legal advice; if the distinction matters to your organisation, have someone qualified read the files.

Contributors face a separate obligation. The README states that pull requests cannot be merged until every committer has signed the Contributor License Agreement, enforced by the license/cla check on a pull request, with the full text at .github/CLA.md. That is a gate on contribution, not on use, but it is worth knowing before you plan to upstream a fix.

The upgrade cost follows from the release pattern. With canary builds landing daily (2026-08-26, 2026-08-27, 2026-08-28 in the recent history) and no stable line visible in that window, staying current means tracking a moving branch. You can pin a build, but the README documents no downgrade procedure and no compatibility matrix between a pinned client and a newer server. Budget for testing each upgrade against your own data rather than assuming a supported upgrade path.

Editorial conclusion

Adopt AFFiNE if you want a single workspace where a document and a whiteboard share the same blocks, and you are willing to run Node 22 and a Rust toolchain from source. Do not adopt it if you need a stable tagged release with documented rollback, or if your team depends on a plugin ecosystem that does not exist yet. Before committing, verify the self-host guide at docs.affine.pro, confirm which LICENSE file applies to the packages you redistribute, and check whether the canary branch cadence matches your upgrade tolerance.

Frequently asked questions

Official sources

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