Folio is very close to the kind of Git-centered knowledge system I keep looking for.

Folio is a self-hosted wiki where the page content lives in Git, while the web app gives people collaborative editing, permissions, search, offline document edits, whiteboards, tables, file previews, AI assistant workflows, and MCP access for agents.

The short version:

Folio = browser wiki + Git repository as source of truth + Postgres/Redis runtime

It is not just a Markdown editor. It is a long-running collaborative web app.

What is Folio?

Folio describes itself as:

The vibe-coded, open-source alternative to Notion and Confluence.

The repository I checked was:

Repository: https://github.com/evergreen-it-dev/folio
Checked commit: 2cf9b6cca2a85b9b1225e76f44bc0434a9102242
Commit date: 2026-10-09
Latest checked tag: v0.1.0
License: MIT
Runtime: Node.js 22, Fastify, React, Vite, PostgreSQL, Redis, Git
Container image tested: ghcr.io/evergreen-it-dev/folio:latest

Each Folio space is a Git repository, or a folder inside one. Documents are Markdown files, whiteboards are editable SVG files, data tables are Markdown table files, and file pages keep their uploaded files in the space.

PostgreSQL does not replace Git as the content source of truth. It stores accounts, access rights, indexes, audit data, and collaborative editing state.

Why It Is Interesting

Most wiki tools store content in a database and offer export later.

Folio flips that:

Git repository = durable content
Database       = operational state, index, access, collaboration

That gives you:

  • normal Git history;
  • commits authored by people;
  • direct edits from an IDE;
  • remote repository sync;
  • Markdown links;
  • readable table files;
  • SVG whiteboards;
  • a way for agents to read and write the same knowledge base.

This is why Folio is worth looking at next to tools like Monolith, Emdash, and the Git-based Astro/Hugo CMS idea. It already proves that a browser-first Git-backed editing workflow can feel like a modern workspace.

Features

Folio currently covers a lot:

Area What Folio Provides
Documents Markdown editor with reading, live edit, and source modes
Collaboration Real-time editing for documents, tables, and whiteboards
Git Spaces backed by Git repositories, delayed commits, sync status, conflict awareness
Whiteboards Excalidraw-based boards stored as SVG
Diagrams Visual Mermaid editor plus Markdown Mermaid blocks
Tables Typed table files with views, filters, sorting, forms
Files PDF, Word, Excel, and PowerPoint preview pages
Offline Opened documents and whiteboards stay editable; offline-created docs/boards sync later
Access Instance admin, space roles, page restrictions, invitations, access requests
Sharing Public share links and .md share output for agents
AI Cursor-backed assistant, .agent folder instructions, assistant analytics
MCP Remote MCP server for Claude, ChatGPT, Codex, Cursor, VS Code, n8n, Open WebUI

The MCP angle is unusually complete. Folio exposes tools for listing spaces, reading pages, searching, creating/updating pages, working with whiteboards, querying/updating data tables, and reading history.

Self-Hosting Folio with Docker

I added a Home-Lab compose folder here:

Home-Lab Folio compose

The compose uses the published container image, PostgreSQL, and Redis:

name: folio

services:
  app:
    image: ${FOLIO_IMAGE:-ghcr.io/evergreen-it-dev/folio:latest}
    container_name: folio
    restart: unless-stopped
    ports:
      - "${FOLIO_BIND:-0.0.0.0}:${FOLIO_PORT:-4870}:4870"
    environment:
      NODE_ENV: production
      PORT: "4870"
      DATABASE_URL: postgresql://folio:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/folio
      REDIS_URL: redis://redis:6379
      PUBLIC_URL: ${PUBLIC_URL:?Set PUBLIC_URL in .env}
      ASSET_BACKEND: local
      FOLIO_SECRET: ${FOLIO_SECRET:-}
      GOOGLE_CLIENT_ID: ${GOOGLE_CLIENT_ID:-}
      GOOGLE_CLIENT_SECRET: ${GOOGLE_CLIENT_SECRET:-}
      GOOGLE_ALLOWED_DOMAINS: ${GOOGLE_ALLOWED_DOMAINS:-}
      CURSOR_API_KEY: ${CURSOR_API_KEY:-}
      CURSOR_AGENT_MODEL: ${CURSOR_AGENT_MODEL:-auto}
      CURSOR_AGENT_WORKSPACE_ROOT: /app/data/assistant/workspaces
      CURSOR_AGENT_STATE_DIR: /app/data/assistant/state
      FOLIO_POSTHOG_KEY: ${FOLIO_POSTHOG_KEY:-}
      FOLIO_POSTHOG_HOST: ${FOLIO_POSTHOG_HOST:-}
      TRUST_PROXY: ${TRUST_PROXY:-}
    entrypoint: ["/sbin/tini", "--", "/bin/sh", "-c"]
    command:
      - |
        set -e
        if [ -z "$$FOLIO_SECRET" ]; then
          secret_file=/app/data/.folio-secret
          if [ ! -s "$$secret_file" ]; then
            umask 077
            node -e "process.stdout.write(require('node:crypto').randomBytes(32).toString('hex'))" > "$$secret_file"
            echo "folio: generated a new secret in $$secret_file"
          fi
          FOLIO_SECRET="$$(cat "$$secret_file")"
          export FOLIO_SECRET
        fi
        exec npx tsx server/index.ts
    volumes:
      - folio-data:/app/data
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    healthcheck:
      test:
        - CMD
        - node
        - -e
        - "fetch('http://127.0.0.1:4870/api/health').then((r)=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 60s

  postgres:
    image: postgres:17-alpine
    container_name: folio-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: folio
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      POSTGRES_DB: folio
    volumes:
      - folio-pg:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U folio -d folio"]
      interval: 5s
      timeout: 5s
      retries: 20

  redis:
    image: redis:7-alpine
    container_name: folio-redis
    restart: unless-stopped
    command: redis-server --save '' --appendonly no

volumes:
  folio-data:
  folio-pg:

Start it:

cd folio
cp .env.sample .env
nano .env
docker compose up -d

Generate the database password once:

openssl rand -base64 32

Then use:

FOLIO_IMAGE=ghcr.io/evergreen-it-dev/folio:latest
FOLIO_PORT=4870
FOLIO_BIND=0.0.0.0
PUBLIC_URL=http://192.168.1.2:4870
POSTGRES_PASSWORD=replace-with-a-long-random-password
FOLIO_SECRET=

FOLIO_SECRET can be empty. In that case Folio generates one on first start and stores it in the persistent app data volume. If you set it manually, keep it permanently because it encrypts saved Git tokens and personal AI keys.

Open:

http://192.168.1.2:4870

The first account created in the browser becomes the instance administrator.

Field Note: Local Trial

I tested Folio locally with the Home-Lab compose.

The stack started three containers:

folio
folio-postgres
folio-redis

The app applied migrations, generated a local FOLIO_SECRET, and became healthy.

Health check:

curl http://127.0.0.1:4870/api/health

Response:

{"ok":true}

The setup endpoint also showed a fresh instance:

curl http://127.0.0.1:4870/api/auth/state
{
  "needsSetup": true,
  "user": null,
  "memberships": {},
  "google": false
}

So yes, you can try the UI at http://192.168.1.2:4870/ and create the first admin account there.

Backup Notes

Folio needs both Git/data and PostgreSQL to be backed up.

The official backup model is:

docker compose exec -T postgres pg_dump -U folio folio > folio-db.sql
docker compose exec -T app tar czf - -C /app/data . > folio-data.tgz

Why both?

Data Where
Wiki content, space repositories, uploads, generated secret /app/data / folio-data volume
Users, roles, access rules, search/index data, collaboration snapshots PostgreSQL
Presence/rate-limit/transient state Redis, intentionally not persistent

If a space is connected to a remote Git repository, the page files also exist there after sync. That still does not replace the database backup, because access and collaboration state are not purely in Git.

FAQ

Conclusion

Folio is one of the more interesting self-hosted wiki projects because it treats Git as the durable knowledge layer instead of a backup/export format.

For a team wiki, internal handbook, engineering knowledge base, or agent-readable workspace, that is compelling. For a public static website CMS, I would treat Folio as inspiration rather than the exact stack: preserve arbitrary front matter, keep assets and photos intentionally modeled, and let Git commits trigger the static build.