BookStack vs Wiki.js: Picking Your Self-Hosted Documentation Platform

You Will Forget How You Set That Up. You Need a Wiki.

It’s been three months. The VPN is broken. You know you fixed this exact problem before, but where did you write that down? In a Notion page you can’t find? A text file on the server itself? That comment in a Docker Compose file you haven’t opened since?

You need a documentation platform. One that lives on your infrastructure, in your control, that you’ll actually write in. The two most popular self-hosted options are BookStack and Wiki.js, and they have genuinely different philosophies about how documentation should work.

The Core Difference: Library vs Brain

BookStack thinks documentation is a library. Content lives in a hierarchy: Shelves contain Books, Books contain Chapters, Chapters contain Pages. It’s opinionated and structured. Your sysadmin notes go in the “Infrastructure” book, under the “Networking” chapter. Tidy. Predictable.

Wiki.js thinks documentation is a connected web of ideas. Pages can link to anything, there’s a real-time graph view of connections, and the structure is more like Wikipedia — organic, emergent, cross-referenced. The sidebar navigation is customizable but less enforced.

Neither approach is wrong. The question is how your brain works when you’re writing. If you like outlines, BookStack. If you like free association and linking, Wiki.js.

Feature Comparison

Resource Requirements

BookStack is a Laravel (PHP) application backed by MySQL. It’s light — runs fine on a 512MB RAM VM. A $5 VPS handles a team of 20 without breaking a sweat.

Wiki.js needs Node.js and can use PostgreSQL, MySQL, SQLite, or MongoDB. Memory usage is a bit higher — plan for 1GB minimum. It also has an optional git storage backend which is excellent but adds complexity.

Docker Compose Setup: BookStack

version: "3.8"
services:
  bookstack:
    image: lscr.io/linuxserver/bookstack:latest
    container_name: bookstack
    restart: unless-stopped
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - APP_URL=https://wiki.yourdomain.com
      - DB_HOST=bookstack-db
      - DB_PORT=3306
      - DB_USERNAME=bookstack
      - DB_PASSWORD=yourpassword
      - DB_DATABASE=bookstack
      - MAIL_DRIVER=smtp
      - MAIL_HOST=smtp.yourdomain.com
      - MAIL_PORT=587
    volumes:
      - ./bookstack-data:/config
    ports:
      - "6875:80"
    depends_on:
      - bookstack-db

  bookstack-db:
    image: lscr.io/linuxserver/mariadb:latest
    container_name: bookstack-db
    restart: unless-stopped
    environment:
      - PUID=1000
      - PGID=1000
      - MYSQL_ROOT_PASSWORD=rootpassword
      - MYSQL_DATABASE=bookstack
      - MYSQL_USER=bookstack
      - MYSQL_PASSWORD=yourpassword
    volumes:
      - ./bookstack-db:/config

Default login after startup: admin@admin.com / password. Change immediately.

Docker Compose Setup: Wiki.js

version: "3.8"
services:
  wiki:
    image: ghcr.io/requarks/wiki:2
    container_name: wikijs
    restart: unless-stopped
    environment:
      DB_TYPE: postgres
      DB_HOST: wiki-db
      DB_PORT: 5432
      DB_USER: wiki
      DB_PASS: yourpassword
      DB_NAME: wiki
    ports:
      - "3000:3000"
    depends_on:
      - wiki-db

  wiki-db:
    image: postgres:15-alpine
    container_name: wikijs-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: wiki
      POSTGRES_USER: wiki
      POSTGRES_PASSWORD: yourpassword
    volumes:
      - ./wiki-db-data:/var/lib/postgresql/data

Wiki.js setup wizard runs on first visit. You’ll configure the admin account, authentication providers, and storage backend through the web UI.

Editor Experience

BookStack’s editor is TinyMCE — the classic WYSIWYG. You can switch individual pages to Markdown mode, but you can’t mix modes in a single page. It’s approachable for non-technical users. The WYSIWYG renders immediately and feels like Google Docs light. Code blocks are decent but not great.

Wiki.js editors — you choose per page, and the options include:

• Markdown (with live preview)
• WYSIWYG
• Code (raw HTML)
• AsciiDoc

The Markdown editor is solid. If your team lives in Markdown already, Wiki.js is more comfortable. BookStack’s Markdown mode works but the WYSIWYG default can feel intrusive if you’re used to typing ## headers.

LDAP and SSO

Both support LDAP for authentication, which matters if you’re running a homelab with centralized auth (Authentik, Keycloak, LLDAP).

BookStack LDAP config (via environment variables):

AUTH_METHOD=ldap
LDAP_SERVER=ldap://yourldap:389
LDAP_BASE_DN=dc=yourdomain,dc=com
LDAP_USER_FILTER=(&(uid=${user})(memberOf=cn=wiki,ou=groups,dc=yourdomain,dc=com))
LDAP_DN=cn=bookstack,ou=services,dc=yourdomain,dc=com
LDAP_PASS=ldappassword
LDAP_USER_TO_GROUPS=true
LDAP_GROUP_ATTRIBUTE=memberOf

Wiki.js SSO is configured through the admin panel under Authentication. It supports LDAP, OAuth2, SAML 2.0, Azure AD, Discord, GitHub, Google — basically everything. The UI for configuring it is cleaner than fumbling with env vars.

Permissions Model

BookStack has roles (Admin, Editor, Viewer, Guest) plus per-content overrides. You can lock specific books to specific roles. It’s straightforward. Not super granular but covers most use cases.

Wiki.js is more granular — you set permissions at the page level if needed. Useful for public wikis where some content is public and some is internal-only, all in the same instance.

Export Options

Both export to PDF and HTML. Wiki.js also has a built-in git storage module that can push your pages to a git repository as Markdown files — brilliant for teams that want version control on their docs or want to grep their wiki with the command line.

BookStack has API exports and can dump content to Markdown. No native git integration.

Which Should You Choose?

Pick BookStack if:

• You want something to onboard non-technical users quickly
• You’re documenting a structured domain (procedures, runbooks, policies)
• You want low maintenance on a small server
• You prefer a book/chapter mental model over free-form linking

Pick Wiki.js if:

• Your team is technical and comfortable in Markdown
• You want git-backed version history
• You need more auth provider flexibility
• You’re building a public-facing knowledge base

My honest take: BookStack is what you use when you want something that works and stays out of your way. Wiki.js is what you use when you want something powerful enough to grow into. For a homelab where it’s mainly you documenting your own setup, BookStack’s simplicity wins. For a team with multiple contributors and varied content types, Wiki.js’s flexibility earns its complexity.

Either way: the best documentation tool is the one you actually write in. Set one up this weekend and write down how you set up your network before you forget again.