Docmost vs Outline vs BookStack: Self-Hosted Wiki and Docs 2026

TL;DR

For self-hosted wikis in 2026, the three strongest open source contenders are Docmost (modern block editor, real-time collab, AGPL), Outline (Notion-like polish, requires S3 + external auth), and BookStack (PHP, hierarchical structure, simplest setup). BookStack wins for ease of deployment and anyone who doesn't have an identity provider set up. Outline wins for teams who want the best editing experience and already run Authentik or Keycloak. Docmost is the rising contender — newer but rapidly improving, with better Draw.io integration than either competitor.

Key Takeaways

• BookStack: ~16K stars, MIT, PHP/Laravel — easiest self-host, built-in email/password auth, hierarchical Books/Chapters/Pages structure
• Outline: ~30K stars, BSL (source-available), TypeScript — best editing experience, requires external auth provider and S3 storage
• Docmost: ~11K stars, AGPL-3.0, TypeScript — newer, real-time collab, native Draw.io, no S3 dependency for basic setup
• Auth gotcha: Outline requires an external OIDC/OAuth provider (no built-in login) — plan for Authentik/Keycloak before deploying
• License: Outline uses Business Source License (not OSI-approved open source) — important if you have legal requirements for OSS-only
• Search quality: Outline has excellent full-text search; BookStack is good; Docmost is catching up

---

Why These Three?

The self-hosted wiki space is crowded — Wiki.js, DokuWiki, TiddlyWiki, XWiki, and Confluence Server all exist. But in 2026, three platforms have pulled ahead for teams that want modern editing experiences without Confluence's cost:

• Docmost emerged from the frustration that Outline requires S3 and an external auth provider just to get started. It launched in 2024 and hit 11K stars faster than most tools in the space.
• Outline is the established Notion-replacement for teams, backed by a small company with a hosted version. The self-hosted edition is free but source-available under BSL.
• BookStack has been shipping monthly releases since 2015, maintained by a solo developer. It's the most opinionated of the three — fixed hierarchy, simpler UI — but it's the easiest to run.

---

Full Feature Comparison

Feature	Docmost	Outline	BookStack
GitHub Stars	~11K	~30K	~16K
License	AGPL-3.0	Business Source License	MIT
Language/Stack	TypeScript (Node.js)	TypeScript (Node.js)	PHP (Laravel)
Editor	Block editor (ProseMirror)	Block editor (ProseMirror)	WYSIWYG + Markdown
Real-time collab	Yes	Yes	No
Spaces/Collections	Yes (Spaces)	Yes (Collections)	Books → Chapters → Pages
Nested pages	Yes (unlimited depth)	Yes	Fixed 3-level hierarchy
Comments	Yes	Yes	Yes
Diagrams	Draw.io native + Mermaid	Mermaid only	Draw.io (plugin)
Templates	Yes	Yes	Yes
Full-text search	Good	Excellent	Good
REST API	Basic	Comprehensive	Yes
Webhooks	Yes	Yes	Yes
Built-in auth	Yes (email/password)	No (requires OIDC/OAuth)	Yes (email/password)
LDAP	Yes	No (via OIDC only)	Yes (native LDAP)
SAML	Yes	No	Yes
OIDC/OAuth	Yes	Yes (required)	Yes
S3/object storage	Optional	Required (or compatible)	No (local disk)
Dark mode	Yes	Yes	Yes
Mobile-friendly	Yes	Yes	Yes
Import from Notion	Yes	Yes	No
Import from Confluence	Partial	Partial	Via plugin
Export	Markdown, PDF	Markdown, PDF	PDF, HTML, Markdown

---

Authentication Deep Dive

Authentication is the biggest friction point when choosing between these three, so it deserves its own section.

BookStack

BookStack has full built-in email/password authentication. You can start using it immediately after installation with no external dependencies. For teams that want SSO later, BookStack supports:

• LDAP (built-in)
• SAML 2.0 (built-in)
• OIDC (built-in)
• Social logins (GitHub, Google, etc. via OAuth)

This makes BookStack the most accessible for teams that don't already have an identity provider.

Docmost

Docmost also includes built-in email/password auth. It additionally supports OIDC for SSO. You can get started without any external auth infrastructure, and add SSO later when your team grows.

Outline

Outline has no built-in email/password login. This is by design — the maintainers want to delegate auth entirely to identity providers. Before your first user can log in, you must configure at least one of:

• Google OAuth (simplest if your team uses Google Workspace)
• Slack OAuth
• OIDC (works with Authentik, Keycloak, Logto, Zitadel, etc.)
• Azure AD / Microsoft 365

For teams already running an identity provider like Authentik, this is a non-issue. For teams starting fresh, it adds a meaningful setup step. See our guide to self-hosting Authentik if you want to set up SSO for Outline.

---

Docker Setup

Docmost

version: "3"

services:
  docmost:
    image: docmost/docmost:latest
    depends_on:
      - db
      - redis
    environment:
      APP_URL: "http://localhost:3000"
      APP_SECRET: "your-long-secret-here"
      DATABASE_URL: "postgresql://docmost:yourpassword@db/docmost"
      REDIS_URL: "redis://redis:6379"
    ports:
      - "3000:3000"
    restart: unless-stopped
    volumes:
      - docmost_data:/app/data/storage

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: docmost
      POSTGRES_USER: docmost
      POSTGRES_PASSWORD: yourpassword
    volumes:
      - pg_data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:7.2-alpine
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  docmost_data:
  pg_data:
  redis_data:

Outline

Outline requires S3-compatible storage for file uploads. MinIO is the standard self-hosted option:

version: "3"

services:
  outline:
    image: docker.getoutline.com/outlinewiki/outline:latest
    environment:
      DATABASE_URL: postgres://outline:yourpassword@postgres:5432/outline
      REDIS_URL: redis://redis:6379
      URL: https://wiki.yourdomain.com
      SECRET_KEY: your-64-char-secret-here
      UTILS_SECRET: your-64-char-utils-secret
      # S3 (MinIO)
      AWS_ACCESS_KEY_ID: minio-access-key
      AWS_SECRET_ACCESS_KEY: minio-secret-key
      AWS_REGION: us-east-1
      AWS_S3_UPLOAD_BUCKET_URL: http://minio:9000
      AWS_S3_UPLOAD_BUCKET_NAME: outline
      AWS_S3_FORCE_PATH_STYLE: "true"
      # Auth (one provider required)
      OIDC_CLIENT_ID: outline
      OIDC_CLIENT_SECRET: your-oidc-secret
      OIDC_AUTH_URI: https://auth.yourdomain.com/application/o/authorize/
      OIDC_TOKEN_URI: https://auth.yourdomain.com/application/o/token/
      OIDC_USERINFO_URI: https://auth.yourdomain.com/application/o/userinfo/
    depends_on:
      - postgres
      - redis
    ports:
      - "3000:3000"
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: outline
      POSTGRES_PASSWORD: yourpassword
      POSTGRES_DB: outline
    volumes:
      - pg_data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:alpine
    restart: unless-stopped

  minio:
    image: minio/minio
    command: server /data --console-address :9001
    environment:
      MINIO_ROOT_USER: minio-access-key
      MINIO_ROOT_PASSWORD: minio-secret-key
    volumes:
      - minio_data:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    restart: unless-stopped

volumes:
  pg_data:
  minio_data:

BookStack

BookStack is the simplest to deploy — just an app container and MySQL/MariaDB:

version: "3"

services:
  bookstack:
    image: lscr.io/linuxserver/bookstack:latest
    container_name: bookstack
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - APP_URL=https://wiki.yourdomain.com
      - APP_KEY=base64:YOUR_GENERATED_KEY_HERE
      - DB_HOST=bookstack_db
      - DB_PORT=3306
      - DB_DATABASE=bookstackapp
      - DB_USERNAME=bookstack
      - DB_PASSWORD=yourpassword
    volumes:
      - ./bookstack_app:/config
    ports:
      - "6875:80"
    restart: unless-stopped
    depends_on:
      - bookstack_db

  bookstack_db:
    image: lscr.io/linuxserver/mariadb:latest
    container_name: bookstack_db
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - MYSQL_ROOT_PASSWORD=yourrootpassword
      - MYSQL_DATABASE=bookstackapp
      - MYSQL_USER=bookstack
      - MYSQL_PASSWORD=yourpassword
    volumes:
      - ./bookstack_db:/config
    restart: unless-stopped

Generate the APP_KEY with: docker run --rm --entrypoint /bin/sh lscr.io/linuxserver/bookstack -c "APP_KEY= php artisan key:generate --show"

---

Content Organization Philosophies

The three tools take fundamentally different approaches to organizing knowledge, and your preference here may be the deciding factor.

BookStack: Fixed Hierarchy

BookStack enforces a strict three-level structure: Books contain Chapters, Chapters contain Pages. You can add a Shelves level above Books. This rigidity is actually a feature for some teams — everyone knows where to put things, and browsing the structure is intuitive for non-technical users. The downside: deeply nested information doesn't map well, and you can't have standalone pages outside a book.

Outline: Flat Collections with Nesting

Outline uses Collections (similar to BookStack's Books) but allows arbitrary nesting depth. Pages can be nested inside other pages without a fixed hierarchy. Search is strong enough that strict organization matters less — Outline encourages a "write first, organize later" workflow. Teams migrating from Notion find this familiar.

Docmost: Spaces with Flexible Structure

Docmost uses Spaces (like Outline's Collections, or BookStack's Books) with unlimited page nesting. The block editor experience is closest to Notion, with slash commands for inserting blocks. The native Draw.io integration for architecture diagrams is a meaningful advantage over Outline (which only supports Mermaid text diagrams).

---

When to Choose Each

Choose Docmost if:

• You want real-time collaboration with a modern block editor
• Draw.io / diagrams.net integration matters (architecture docs, system diagrams)
• You want true AGPL open source (not source-available like Outline's BSL)
• You're willing to accept a less mature project in exchange for faster improvement velocity

Choose Outline if:

• You already have an OIDC provider (Authentik, Keycloak, Google Workspace, etc.)
• Search quality and breadth of integrations are top priorities
• You're migrating from Notion and want the closest equivalent experience
• You need a polished API for programmatic doc management

Choose BookStack if:

• You want the quickest path to a working wiki (no auth provider, no S3)
• Your team is non-technical and benefits from a fixed, predictable structure
• LDAP/SAML integration is needed without an intermediate identity provider
• MIT license is required for organizational or compliance reasons

---

For more on self-hosted documentation tools, see our guide to the best open source Confluence alternatives, our self-hosting guide for Outline, and our how to self-host Docmost guide. If you need SSO for Outline, see our Authentik vs Keycloak vs Authelia comparison.

---

Migrating Between These Tools

Knowledge base migrations are painful but sometimes necessary. Here's what to expect.

Confluence → BookStack: The most common migration path. The confluence2bookstack community tool handles basic content. Tables, page hierarchy, and text content migrate reasonably well. Macros, attachments, and complex formatting require manual cleanup. BookStack's official migration guide covers the process step by step.

Confluence → Outline: Outline's import handles Confluence HTML exports. Nested page structures flatten into Outline's collection model. Images and attachments require separate handling. Expect to spend time reorganizing content that doesn't map cleanly to flat collections.

Notion → Docmost or Outline: Both tools accept Notion HTML and Markdown exports. The block editor structure is similar enough that most content migrates with reasonable fidelity. Notion databases don't have an equivalent — they become static tables or need to be moved to a dedicated tool.

Between the three: Moving between BookStack, Outline, and Docmost generally requires exporting to Markdown from the source and re-importing. None of the three have direct migration paths between each other, though community scripts exist for common migrations.

---

Permissions and Access Control

For teams, the permission model matters as much as the editing experience.

BookStack has the most granular permission system: you can control read, create, update, and delete access independently at the Shelf, Book, Chapter, and Page level, for both roles and individual users. LDAP/SAML integration means you can sync groups from your directory server to BookStack roles automatically. This makes BookStack the strongest choice for organizations with complex access requirements.

Outline uses a simpler model: workspace-level roles (Admin, Member, Viewer) plus collection-level permissions (read-only, read-write). Guest access via share links works for external sharing without accounts. The lack of built-in auth means you rely on your OIDC provider's groups to map to Outline roles.

Docmost supports role-based permissions at the Space level. Admin, Member, and Viewer roles exist at the workspace level, with Space-level overrides. The permission model is simpler than BookStack but suitable for most team use cases. SAML and OIDC support allows SSO-based role assignment.

---

Performance at Scale

All three tools are fast for typical team use (under 1,000 pages, under 100 users). At scale, differences emerge.

BookStack can handle large page counts well — the MySQL-backed search is fast and well-indexed. PHP can be slow for large page trees if not configured with opcache, but the LinuxServer Docker image handles this. Nginx in front of BookStack is recommended for production.

Outline is fast for editing but search performance depends heavily on PostgreSQL configuration. On large wikis (10,000+ pages), search can become slow without proper Postgres tuning (full-text search indexes). The S3 requirement means file uploads are not bottlenecked by your application server.

Docmost is newer and less tested at large scale. For most teams under 500 pages, performance is excellent. Watch GitHub issues for reports on large-scale performance as the project matures.

---

Methodology

• Sources consulted: 7
• GitHub star data from GitHub.com, March 2026
• Docker Compose configs from official documentation for each project
• License information verified from project repositories
• Date: March 2026