Self-hosted wiki: BookStack, Wiki.js, Outline

Which self-hosted wiki should you run

A self-hosted wiki puts your team's documents in one searchable place on a server you control. BookStack, Wiki.js and Outline all do that job. They differ most in how much you have to assemble before the first page loads, and in who is allowed to log in.

BookStack is the lightest to stand up and the most opinionated about structure. Wiki.js gives you the widest choice of editors over one page tree. Outline has the best writing experience of the three, and it will not let anyone sign in until you connect an outside identity provider.

Everything below is read from the projects' own documentation and their published configuration files. This is a capability comparison, not a benchmark. Version numbers and requirements are stamped with a date because all three move.

Structure is the real choice

BookStack fixes the shape of your content. A page lives inside a book, a book may hold chapters, and shelves group books. You cannot invent a fifth level. That limit is the product: a new writer knows where a page goes because there is only one place it can go. The cost is that content which does not fit the shape gets forced into it.

Wiki.js uses a path tree, like folders on a disk. A page at ops/backup/restic sits wherever you put it, and you pick the depth. Nothing stops two people filing the same subject under two different branches, so a Wiki.js instance needs one person who owns the tree.

Outline uses collections with documents nested inside documents. Moving a document is a drag with the mouse. It is the most flexible of the three, so it is also the easiest to let drift.

BookStack: the smallest install

BookStack is a PHP application backed by MySQL. As of July 2026 the documented requirements are PHP 8.2 or newer and either MySQL 8.0 or MariaDB 10.6 or newer, plus Composer 2.2 or newer if you install from source. The current release line is 26.05.

The project publishes one installation script per Ubuntu release. The 24.04 script installs Apache, MySQL 8.0 and PHP 8.3 for you.

wget https://codeberg.org/bookstack/devops/raw/branch/main/scripts/installation-ubuntu-24.04.sh
chmod a+x installation-ubuntu-24.04.sh
sudo ./installation-ubuntu-24.04.sh

Read the warning on that script before you run it. The documentation states it is "ONLY FOR A FRESH OS, it will install Apache, MySQL 8.0 & PHP 8.3 and could OVERWRITE any existing web setup on the machine". On a server that already answers on port 80, the script takes that port and rewrites the Apache configuration. Use containers there instead, or install BookStack by hand on top of an existing LAMP stack on Ubuntu 24.04.

The container route uses the LinuxServer.io image, which is the option the BookStack documentation points at. BookStack needs a session encryption key and will not serve pages without one, so generate it first.

docker run -it --rm --entrypoint /bin/bash lscr.io/linuxserver/bookstack:latest appkey

Copy the printed value into APP_KEY, then write the service:

services:
  bookstack:
    image: lscr.io/linuxserver/bookstack:latest
    container_name: bookstack
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
      - APP_URL=https://wiki.example.com
      - APP_KEY=paste_the_generated_key_here
      - DB_HOST=bookstack_db
      - DB_PORT=3306
      - DB_USERNAME=bookstack
      - DB_PASSWORD=change_me
      - DB_DATABASE=bookstackapp
    volumes:
      - ./config:/config
    ports:
      - 6875:80
    restart: unless-stopped

APP_URL has to match the address readers actually type, including the scheme and any port. Set it to http://localhost and then serve the site over HTTPS, and generated links and redirects point at the wrong host, which readers see as a login page that loops back to itself. If compose files are new to you, start with Docker Compose basics on a VPS before this one.

Bring it up and check that the application answers, not only that the container is running:

docker compose up -d
docker compose ps
curl -sI http://127.0.0.1:6875/login

A 200 OK means the PHP application booted and reached the database. A 500 almost always means APP_KEY is empty or the database credentials do not match, and docker compose logs bookstack prints which of the two it is.

Wiki.js: one tree, several editors

Wiki.js is a Node.js application. The documented Docker setup pairs it with PostgreSQL, though the software also accepts MySQL, MariaDB, MSSQL and SQLite. This is the compose file from the project's own Docker page:

services:
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: wiki
      POSTGRES_PASSWORD: wikijsrocks
      POSTGRES_USER: wikijs
    logging:
      driver: none
    restart: unless-stopped
    volumes:
      - db-data:/var/lib/postgresql/data
  wiki:
    image: ghcr.io/requarks/wiki:2
    depends_on:
      - db
    init: true
    environment:
      DB_TYPE: postgres
      DB_HOST: db
      DB_PORT: 5432
      DB_USER: wikijs
      DB_PASS: wikijsrocks
      DB_NAME: wiki
    restart: unless-stopped
    ports:
      - "80:3000"
volumes:
  db-data:

Change POSTGRES_PASSWORD and DB_PASS together before you run it, because they are one credential and the sample value is public. The tag is pinned to ghcr.io/requarks/wiki:2 on purpose. The documentation recommends against latest, since a major version jump changes the database schema under a running instance.

Version 2 is the line to run. As of July 2026 the newest version 2 release is 2.5.314, from May 2026. Version 3 exists, and its own documentation says: "This site is for the unstable beta release of Wiki.js 3.0. You should NOT install this in production." Treat the :3 tag as a preview.

On first load Wiki.js walks you through an in-browser setup that creates the administrator account. Until you finish it, anyone who reaches the port gets that wizard, so put the service behind your reverse proxy and TLS (transport layer security) before you open the firewall. A wiki on its own hostname sits naturally behind Traefik in front of several Docker apps when the server hosts more than this one service.

The editor choice is the reason people pick Wiki.js. One instance can hold Markdown pages, visual editor pages, raw HTML pages and AsciiDoc pages side by side. That helps when you are importing old content in a format you would rather not convert. It is also a way to end up with four house styles in one wiki, so decide the default editor on day one and write that decision down.

Outline: the best editor, the heaviest prerequisites

Outline is what people usually mean when they say they want something that feels like a commercial notes tool. It is a Node.js application, and the current release as of July 2026 is 1.9.2. Its sample environment file lists what it needs: PostgreSQL through DATABASE_URL, Redis through REDIS_URL, two random secrets, and a publicly reachable URL.

openssl rand -hex 32
openssl rand -hex 32

Run that twice and keep both values. The first becomes SECRET_KEY, the second UTILS_SECRET. The core of the environment file then looks like this:

NODE_ENV=production
URL=https://docs.example.com
PORT=3000
SECRET_KEY=<first openssl value>
UTILS_SECRET=<second openssl value>
DATABASE_URL=postgres://outline:change_me@postgres:5432/outline
PGSSLMODE=disable
REDIS_URL=redis://redis:6379
FILE_STORAGE=local
FILE_STORAGE_LOCAL_ROOT_DIR=/var/lib/outline/data

PGSSLMODE=disable is only correct when the database sits on the same machine or the same Docker network. Leave it out for a database reached across a network, or the connection travels in the clear. Attachments no longer force you into object storage: FILE_STORAGE=local writes uploads to the directory above, which must be a volume the container can write to and something your backups include. Set FILE_STORAGE=s3 with the AWS_* values instead if you want those files in an S3 compatible bucket.

Now the part that surprises people. Outline has no built-in username and password login. Its own sample configuration says third party sign-in credentials are required: "at least ONE OF these is required for a working installation or you'll have no sign-in options". The documented providers include Google, Slack, Microsoft Entra, Discord, and any generic OpenID Connect (OIDC) server through OIDC_CLIENT_ID, OIDC_CLIENT_SECRET, OIDC_AUTH_URI, OIDC_TOKEN_URI and OIDC_USERINFO_URI.

So the honest cost of Outline is Outline plus PostgreSQL plus Redis plus an identity provider. If your team already signs in with Google Workspace or Microsoft Entra, that last piece costs you ten minutes and Outline becomes very attractive. If it does not, you are also self-hosting something like Keycloak or Authentik, which is a second service to patch and back up. Budget memory accordingly: Outline's own guidance is roughly 512 MB per web process, set by WEB_CONCURRENCY, on top of the database and Redis.

How each one handles who may read what

BookStack has local email and password accounts out of the box, and supports LDAP, SAML2 and OIDC as alternatives. Permissions are set per role and can be overridden on a single shelf, book, chapter or page. Because the hierarchy is fixed, permissions inherit down it in a way you can predict.

Wiki.js also ships local accounts and adds a long list of strategies you enable in the admin area. Its page rules grant or deny by path pattern. That is powerful and easy to get wrong, because a rule written for ops/* silently covers every page you file under that path later.

Outline delegates the question entirely. Membership follows your identity provider, and inside Outline you control access by collection and by group. There is no local account left behind when someone leaves the company, which is a real advantage when the identity provider is already the system you deprovision through.

How search works in each

Search is where a wiki either earns its place or turns into a folder of forgotten files.

BookStack searches the database and gives readers a query language they can learn in a minute. Quoting a phrase, as in "london meeting", requires that exact string. Square brackets search tags: [location=london] matches by tag name, value or both, with comparisons including !=, >= and like. Curly braces filter on metadata, as in {created_after:2016-12-30}. Any exact, tag or filter term can be negated by prefixing it with -. BookStack caps how many terms of each type one query may hold, so a very long query is trimmed rather than run.

Wiki.js treats search as a pluggable module. The documented engines are a basic database engine, a PostgreSQL engine, Elasticsearch, Algolia, AWS CloudSearch and Azure Search. The basic engine is fine for a few hundred pages. If you run PostgreSQL, switch to the PostgreSQL engine in the admin area, because it uses the database's own full text index instead of simple matching. Keep Elasticsearch for a wiki large enough that you accept running and patching a second search service.

Outline searches PostgreSQL full text indexes. There is no engine to choose and nothing to tune, and it also searches the text inside uploaded documents. For a team wiki in the low thousands of documents that is the least work of the three. There is also no lever to pull if it ever stops being fast enough.

Which one fits you

Pick BookStack if you want the wiki running this afternoon and you would rather argue about content than about structure. It has the fewest moving parts: one PHP application and one MySQL database. It suits internal runbooks and customer documentation, and it suits teams where most writers are not engineers. It is also the easiest of the three to back up, because the whole state is one database dump plus the uploads directory.

Pick Wiki.js if you need a specific editor or a specific authentication strategy the others do not offer, or if you are importing a large body of existing Markdown or AsciiDoc and want the path structure preserved. Accept that you are running a heavier stack, and pin the major version tag.

Pick Outline if writing quality matters most, the wiki is for a team rather than for the public, and you already have an identity provider. It rewards that setup with the editor people actually enjoy using. Do not pick it as your first self-hosted application.

If none of the three fits, the mismatch is usually the content type. Scanned invoices and contracts belong in a document management system such as Paperless-ngx rather than in a wiki, and forcing them into one is why so many wikis end up abandoned. For a wider view of what else earns a place on your own server, see the self-hosting shortlist for 2026.

Sizing and backups

All three fit on a small VPS, and the realistic floor differs because of what sits behind each one. BookStack is one application process and MySQL. Wiki.js is a Node process and PostgreSQL. Outline is a Node process, PostgreSQL and Redis, usually with an identity provider alongside, which is why it is the one to give extra memory.

Back up the database and the uploads together, and restore both into a throwaway instance once before you rely on that backup. A wiki backup nobody has restored is a guess. For BookStack that means a mysqldump plus the /config volume. For Wiki.js and Outline it means pg_dump plus the data volume, and for Outline also whatever sits in FILE_STORAGE_LOCAL_ROOT_DIR.

FAQ

Which self-hosted wiki is easiest to install?

BookStack. It is a single PHP application with a MySQL database, and the project ships an installation script for Ubuntu 24.04 that sets up Apache, MySQL 8.0 and PHP 8.3 in one run. The container image needs only an APP_KEY and database credentials. Wiki.js adds a Node runtime and a PostgreSQL server, and Outline adds Redis and an outside identity provider on top of that.

Can I use Outline without Google or another SSO provider?

No. Outline has no local username and password login. Its sample configuration states that at least one third party sign-in provider is required, or you will have no sign-in options at all. You can use Google, Slack, Microsoft Entra, Discord, or any generic OpenID Connect server such as a self-hosted Keycloak or Authentik. Running that provider is part of the cost of running Outline.

Should I install Wiki.js 3 or Wiki.js 2?

Version 2. As of July 2026 the newest version 2 release is 2.5.314, from May 2026, and the version 3 documentation says plainly that it is an unstable beta you should not install in production. Pin your image to ghcr.io/requarks/wiki:2 rather than latest, because a major version change alters the database schema under a running instance.

Which one has the best search?

They are strong in different ways. BookStack gives readers a query language with exact phrases, tag filters such as [location=london] and metadata filters such as {created_after:2016-12-30}, and any of those terms can be negated with a leading -. Outline needs no configuration and searches the text inside uploaded files. Wiki.js is the most tunable, since you choose the engine, and the PostgreSQL engine is worth switching to as soon as your wiki outgrows a few hundred pages.

Can I move my content from one to another later?

Partly, and you should expect manual work. All three export and import Markdown, so page text usually survives. Structure does not survive cleanly: BookStack books and chapters have no equivalent in Outline's nested documents, and Wiki.js paths do not map onto BookStack's fixed hierarchy. Attachments, permissions and page history are the parts most likely to be lost, so export a sample and check those before you commit to a migration.