[opensourcedex]

AnyType is a free, open source note taking & knowledge management project written in TypeScript and released under a custom open-source licence. It has 8,828 GitHub stars, 580 forks and 209 open issues, and was last pushed 15 hours ago. On this registry it ranks #16 of 25 tracked projects in Note Taking & Knowledge Management, and is listed as an open source replacement for 1 paid product, with 5 head-to-head comparisons available. It gained 39 stars over the last 6 tracked days.

What is AnyType?

Anytype Desktop is the official cross-platform client for Anytype, a local-first, peer-to-peer, end-to-end-encrypted personal knowledge base for macOS, Windows and Linux, built for people who want Notion-style pages, tasks and databases while keeping their data on their own devices.

What it is

Anytype is a personal knowledge base — the README calls it a digital brain — that lets users gather, connect and remix information. Pages, tasks, wikis, journals and even entire apps are assembled from composable blocks, and the data model itself is user-defined through custom Types. The client lives in the our own ecosystem as the desktop front end to the anytype-heart middleware, and it is written in TypeScript and built with Electron.

The concrete problem it solves is ownership. Anytype stores data offline-first on local storage, syncs optionally over peer-to-peer, and encrypts it with zero-knowledge encryption powered by any-sync. That combination replaces the hosted workspace model of Notion, which the project explicitly positions itself as an open alternative to. Instead of content living on a vendor's servers under a vendor's account, the workspace lives on the user's machine and is reachable across devices through an Any-ID.

Key capabilities

  • Offline-first local storage with optional peer-to-peer sync, so the workspace opens and works without a network connection.
  • Zero-knowledge encryption powered by any-sync, covering the synced state across devices.
  • Composable blocks covering text, databases, kanban, calendar and custom Types, which together allow user-defined data models.
  • Cross-platform desktop client built with Electron and TypeScript, shipped for macOS, Windows and Linux.
  • Extensibility through a gRPC API and AI "Agents", documented in AGENTS.md.
  • Localisation managed through Crowdin and refreshed with bun run update:locale.
  • Build flags such as ELECTRON_SKIP_NOTARIZE to skip macOS and Windows signing and notarizing, and ELECTRON_SKIP_SENTRY to skip sourcemap uploads.

Who uses it and how

  • Individuals running a personal knowledge base of notes, journals and tasks on a single desktop, with no server to maintain.
  • Privacy-conscious users who need end-to-end encryption and local storage rather than a hosted workspace account.
  • Teams assembling shared wikis and databases from block-based pages, syncing peer-to-peer between members' machines.
  • Developers building from source on ARM systems, where the keytar package must be rebuilt with a C++ compiler, Python3 and setuptools.
  • Translators contributing localisations through the project's Crowdin project.

Getting started

Download the latest installer from the releases page or from download.anytype.io, then log in with an Any-ID. Building from source instead requires bun install, running ./update.sh, building the anytype-heart middleware, running bun run generate:protos and bun run dist:.

How it compares

Notion is the product Anytype is positioned against, and the contrast is structural: Anytype ships its desktop code under the Any Source Available License 1.0, stores data locally first and syncs peer-to-peer, so the workspace does not depend on a vendor's hosted account. Notion is a proprietary hosted service, whereas Anytype can be built from source, run offline and extended through its gRPC API.

When to use it — and when not to

Pick it when local ownership and encryption matter more than zero-setup convenience, and accept that a source build is genuinely involved: keytar must be rebuilt, Linux needs the protobuf compiler with well-known .proto files, and steps 3 to 5 produce git-ignored middleware/ and src/ts/lib/api/service.ts assets whose absence breaks the build with Failed to resolve import "./service" from src/ts/lib/api/dispatcher.ts. Avoid it if you need a standard permissive open-source licence, since the code is released under the Any Source Available License 1.0 and the registry records the licence as NOASSERTION. Note also that 209 issues are open against 8,826 stars, so expect an actively moving target rather than a static product.

project readme (upstream, from github) — read inline

Anytype Desktop

Local‑first, peer‑to‑peer & end‑to‑end‑encrypted knowledge OS for macOS, Windows & Linux.

Latest release Build Status Crowdin License

Anytype is a personal knowledge base—your digital brain—that lets you gather, connect and remix all kinds of information. Create pages, tasks, wikis, journals—even entire apps—and define your own data model while your data stays offline‑first, private and encrypted across devices.

✨ Key Features

  • Offline‑first, local storage with optional peer‑to‑peer sync.
  • Zero‑knowledge encryption powered by any‑sync.
  • Composable blocks: text, databases, kanban, calendar & custom Types.
  • Cross‑platform desktop client built with Electron + TypeScript.
  • Extensible through a gRPC API and AI "Agents" (see AGENTS.md).
  • Open code under the Any Source Available License 1.0.

📚 Table of Contents

🚀 Quick Start

Just want to try it? Grab the latest installer from the releases page or head to download.anytype.io and log in with your Any‑ID.

🏗 Building from Source

On ARM systems, node package keytar needs to be rebuilt during installation, so make sure that your system has a C++ compiler, Python3 and Python package setuptools. E.g. on Debian/Ubuntu: sudo apt install python3-setuptools. Alternatively, on any system, create a Python virtual environment (venv) and inside the venv: pip install setuptools. Then build from source inside the venv.

Linux also needs the protobuf compiler with the well-known .proto files (used to generate the gRPC bindings in step 5):

  • Fedora: sudo dnf install protobuf-compiler protobuf-devel jq
  • Debian / Ubuntu: sudo apt install protobuf-compiler libprotobuf-dev jq
# 1 – Clone & open this repository
git clone https://github.com/anyproto/anytype-ts.git && cd anytype-ts

# 2 - Install JavaScript dependencies
bun install

# 3 – Fetch the prebuilt middleware binary + proto/JSON assets into dist/
./update.sh <macos-latest|ubuntu-latest|windows-latest> <arm|amd>

# 4 – Build the core engine
cd .. && git clone https://github.com/anyproto/anytype-heart.git && cd anytype-heart
make install-dev-js CLIENT_DESKTOP_PATH=../anytype-ts && cd ../anytype-ts

# 5 – Generate protobuf bindings (middleware/) + service registry (src/ts/lib/api/service.ts)
#     From the anytype-heart checkout built in step 4:
bun run generate:protos
#     …or, to skip the anytype-heart checkout entirely, generate from the assets fetched in step 3:
#     bash scripts/generate-protos.sh --from-dist

# 6 - Update locale
bun run update:locale

# 7 – Build the Electron desktop app (see package.json for more options)
bun run dist:<linux|win|mac>

Steps 3–5 produce middleware/ and src/ts/lib/api/service.ts, which are git-ignored. Skipping step 5 causes Failed to resolve import "./service" from src/ts/lib/api/dispatcher.ts. See Updating Protobuf Bindings and scripts/README.md for details.

Environment flags

Variable Effect
ELECTRON_SKIP_NOTARIZE Skip macOS / Windows signing & notarizing
ELECTRON_SKIP_SENTRY Don’t upload sourcemaps to Sentry

🧑‍💻 Development Workflow

You can use nix to install all the required dependencies at once.

# open a shell with all the required dependencies
nix develop --command $SHELL

Start the dev server with hot‑reload (builds Electron bundle, starts Vite, then launches Electron):

bun run start:dev     # Windows: bun run start:dev-win
# add --user-data-dir=./my_dir to electron(-win) script in package.json if you want to use custom user data directory

When you close Electron, the Vite dev server is automatically stopped.

For browser-based development without Electron:

bun run start:web

See Web Mode for details.

Useful commands

bun run build         # Production build (Vite)
bun run build:dev     # Development build (Vite)
bun run typecheck     # TypeScript type checking
bun run lint          # Run linters (Biome + ESLint)

Environment variables

Name Purpose
SERVER_PORT Vite dev server port (default: 8080)
ANYPROF Expose Go pprof on localhost:

Web Clipper Extension

Build and switch manifest for different browsers:

bun run build:ext
bun run ext:manifest:firefox
bun run ext:manifest:chromium

Updating Middleware

The middleware version is pinned in middleware.version. To fetch a pre-built middleware binary and its protobuf/JSON assets:

./update.sh <macos-latest|ubuntu-latest|windows-latest> <arm|amd>

This downloads the anytype-heart release matching the version in middleware.version, extracts the anytypeHelper binary into dist/, and copies protobuf definitions and generated JSON into dist/lib/.

For CI environments (requires GitHub credentials):

./update-ci.sh --user=<GITHUB_USER> --token=<GITHUB_TOKEN> --os=<OS> --arch=<ARCH> --middleware-version=<VERSION>

Updating Protobuf Bindings

The TypeScript protobuf bindings (middleware/) and the gRPC service registry (src/ts/lib/api/service.ts) are generated and git-ignored — a fresh checkout has neither, and the dev/build will fail with Failed to resolve import "./service" from src/ts/lib/api/dispatcher.ts until you generate them.

From a local anytype-heart checkout (expected at ../anytype-heart, requires the Go toolchain):

bun run generate:protos

Without an anytype-heart checkout (uses the .proto files downloaded by ./update.sh into dist/lib/protos/):

./update.sh <macos-latest|ubuntu-latest|windows-latest> <arm|amd>
bash scripts/generate-protos.sh --from-dist

Prerequisites: bun install must have been run (for ts-proto), and protoc plus the well-known google/protobuf/*.proto files must be installed:

  • Fedora: sudo dnf install protobuf-compiler protobuf-devel
  • Debian / Ubuntu: sudo apt install protobuf-compiler libprotobuf-dev
  • macOS: brew install protobuf

The -devel / -dev package is required on Linux — without it protoc reports google/protobuf/struct.proto: File not found. See scripts/README.md for the full Linux first-time setup and troubleshooting.

🌍 Localisation

Translations live on Crowdin. Pull the latest locale files with:

bun run update:locale

🤝 Contributing

We ♥ contributors! Please read our Contributing Guide and follow the Code of Conduct.

Security issues? Don’t open public issues—email [email protected] and see our Security Guide.

💬 Community & Support

  • Forum –
  • Docs –
  • Blog –

📝 License

Made by Any — a Swiss association 🇨🇭

Licensed under the Any Source Available License 1.0.

Frequently asked questions

Is AnyType free to use?

AnyType is open source. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does AnyType do?

Private workspace for notes, tasks, and databases

What is AnyType written in?

AnyType is primarily written in TypeScript. Its source is publicly available at https://github.com/anyproto/anytype-ts, and it has 8,828 GitHub stars.

What is a good open source alternative to Notion?

AnyType is one of the open source options listed as an alternative to Notion. Compare licences, stars and activity side by side on the AnyType profile.