folio

# Folio

**The vibe-coded, open-source alternative to Notion and Confluence.**
Your team's wiki lives in Git. People write in the browser, together, in real
time. AI agents read and write the same pages. One command to run it yourself.

Website: <https://foliowiki.online> · Featured in [Self-Host Weekly (9 Oct 2026)](https://selfh.st/weekly/2026-10-09/)

### 👉 [Try the live demo](https://demo.foliowiki.online/?utm_source=github&utm_medium=readme&utm_campaign=repo)

No install, no sign-up: open it and pick Sam on the sign-in screen. Shared login, data resets every 24 hours; don't enter personal data or API keys.

![A page in Folio](docs/images/document.png)

Folio was built to replace Confluence and Notion for a real team — and it was
built by AI agents, in the open. The plans, specs and hand-off notes the agents
work from are in this repository, next to the code they wrote.
[More on that below.](#vibe-coded-and-not-hiding-it)

```bash
git clone https://github.com/evergreen-it-dev/folio.git
cd folio
docker compose up -d
```

Open <http://localhost:4870>, create the first account, start writing.

Not ready to install? [Try the live demo](https://demo.foliowiki.online/?utm_source=github&utm_medium=readme&utm_campaign=repo) first.

---

## Why Folio

- **You own the content.** Every page is a plain file in a Git repository you
  control. No export step, no lock-in: stop using Folio tomorrow and the files
  are still there, readable in any editor.
- **It works the way a wiki should.** Real-time editing, a page tree, search,
  access rights, history, sharing — and it keeps working offline.
- **Agents are first-class users.** Not a chatbot bolted on the side: a
  built-in assistant, your own agent in every space, a full MCP server, and
  Markdown links made for agents.
- **Documents, tables, whiteboards, diagrams and files in one tree.** A
  roadmap table next to the spec, next to the architecture board, next to the
  signed PDF.
- **Publish what should be public.** Turn a space into a read-only website,
  with search and an optional "Ask AI", on your own domain.
- **One command to run.** Docker, and nothing to configure for a first start.

---

## See it in action

Short walkthroughs, no slides. The voice in the videos is synthetic.

- [A team wiki that lives in Git](https://youtu.be/tm1xB9x9HeY) — edit a page in the browser, press Sync, and it is a real Git commit; a teammate edits from the terminal and the change shows up on the page (0:37)
- [An AI agent updates your wiki over MCP](https://youtu.be/3ORtBgYlIeY) — one request: the agent reads the release process, writes release notes and adds a roadmap row (0:53)
- [Onboarding a sales rep with Folio AI](https://youtu.be/T4JXTNRrsMg) — answers from the team's own pages with sources, a weekly check as a form, and the results in a table (1:22)
- [Whiteboards that live in Git](https://youtu.be/HNK17qafhtc) — draw together, embed the board in a document, and keep every version in history (0:51)
- [The editor and Mermaid diagrams](https://youtu.be/MfK7bhKoxSs) — live Markdown, a source view of the same page, and diagrams you edit visually or as code (1:04)
- [Is your wiki's AI assistant helping? Folio AI analytics](https://youtu.be/7aszLTDQV8w) — instance admins see rated conversations and unanswered questions, add the missing page, and the same question gets an answer with its source (1:21)

---

## Git-first, all the way down

Most wikis keep your content in a database and offer Git as an export. Folio
does the opposite: **the Git repository is the wiki**. The database holds the
index, access rights and the state of live editing — never the only copy of
your words.

This is what a space looks like on disk:

```text
acme-handbook/
├── index.md
├── welcome-to-acme.md
├── engineering.md
├── engineering/
│   ├── onboarding-checklist.md
│   ├── release-process.md
│   ├── incident-runbook.md
│   └── how-folio-fits-together.excalidraw.svg    ← a whiteboard
├── meeting-notes.md
├── meeting-notes/
│   └── product-sync-september-28.md
├── roadmap.table.md                               ← a data table
├── onboarding-feedback.table.md
├── onboarding-feedback/
│   └── onboarding-feedback.form.md                ← a form
├── security-policy.md
├── security-policy.pdf                            ← files are pages too
└── security-policy.docx
```

And this is its history — ordinary commits, with the people who made the
changes as authors:

```text
$ git log --format='%h  %an  %s'
be529a0  Maria Chen  folio:update
aeac3bb  Maria Chen  folio:update
6c2c061  Sam Rivera  folio:update
026d9ec  Maria Chen  folio:update
...
4e9ec49  Folio       init: create space
```

What that gives you:

- **Edit anywhere.** Change a page in the browser or in your IDE and push —
  both land in the same history. Links between pages are ordinary relative
  Markdown links, not a private dialect.
- **Bring your own repository.** Start with an empty space, clone an existing
  repository, or connect one later. Several spaces can share one repository,
  each in its own folder — so documentation can live right next to the code.
- **Review like code.** Merge requests, blame, diff and revert work on your
  wiki because it *is* a repository.
- **Docs-as-code friendly.** Front matter written by Docusaurus, MkDocs, Hugo or
  Jekyll is kept byte for byte; a space bound to a folder such as `docs/`
  writes no ids into your files; images can be stored in the repository next to
  the page and linked by a relative path, so GitHub shows them; and moving a
  page rewrites the links that point to it and the ones inside it, in one
  commit.
- **Nothing is lost quietly.** Sync state is always visible — clean, ahead,
  behind, conflict — and conflicts are listed for the whole space. "Take the
  version from Git" resets a space to the remote branch and saves what was
  there into a backup branch first.
- **Readable formats.** A whiteboard is an SVG that opens in any browser and
  still carries the editable scene. A data table is one Markdown file — the
  column types and saved views in the front matter, the rows as a table you
  can read:

```markdown
# Roadmap

| Initiative | Status | Owner | Team | Due | Effort, days | Urgent | id |
| --- | --- | --- | --- | --- | ---: | --- | --- |
| Single sign-on for enterprise plans | In progress | @alex | Engineering | 2026-10-09 | 8 | [x] | 1787nfg3 |
| New onboarding flow | In review | @sam | Design | 2026-10-02 | 5 | [ ] | b227mwwh |
| Pricing page redesign | Planned | @sam | Design | 2026-10-16 | 3 | [ ] | ndxvtpa3 |
```

![Page history with authors](docs/images/history.png)

---

## Write together

Documents, data tables and whiteboards are edited by several people at once.
You see who is on the page and where their cursor is; changes appear as they
are typed. When the page goes quiet, Folio commits — with the person who
edited as the author.

![Three people editing one page](docs/images/collab.png)

What you type is not lost between Live edit and Reading: the browser keeps a
local copy until the server confirms it has your edits. If it cannot confirm
them, the header says **Not saved** and closing the tab asks first.

---

## Works offline

On a train, on a plane, on bad hotel Wi-Fi — keep writing.

- Pages and whiteboards you have opened stay editable without a connection.
- New pages and whiteboards can be created offline and appear in the tree
  straight away.
- Everything is kept on the device and reaches the server by itself when the
  connection returns — at the same address, with no duplicates.
- Nothing is lost if you switch pages or close the tab.
- An indicator in the header shows what is waiting to be sent.

![Writing a new page without a connection](docs/images/offline.png)

Data tables, forms and file uploads need a connection.

---

## Documents

A Markdown editor that does not make you think about Markdown. Three modes —
**Reading**, **Live edit** and **Source** — so that writers and engineers are
both at home.

![The editor with a diagram, a checklist and a callout](docs/images/editor.png)

- Callouts, checklists, tables with merged cells and colors, code blocks,
  collapsible sections, highlights, `++underline++`, and coloured status
  tags like `:status[Done]{color=green}`.
- Paste from Excel and Google Docs keeps tables and formatting; copying out of
  Live edit keeps it too.
- `[[` links a page, `@` mentions a person, `/` inserts anything.
- `::pagetree` puts a live tree of child pages right into the text.
- Outline and notes panel, backlinks, page icons and covers, templates,
  glossary terms with hover cards.
- Light and dark themes, following the system or chosen by hand.

![The same page in the dark theme](docs/images/document-dark.png)

---

## Diagrams you draw, not type

Mermaid diagrams come with a visual editor. You build the diagram on a canvas,
and Folio writes the Mermaid code for you — or you type the code and watch the
canvas follow. Both sides stay in sync.

![The visual Mermaid editor](docs/images/mermaid.png)

- **Click to build.** A plus on a node adds a connected one, a plus on a link
  inserts a node into it, a handle drags a new link from node to node.
- **Nine diagram types from templates**: flowchart, sequence, classes, states,
  ER, Gantt, timeline, pie, mind map.
- **Code and canvas side by side**, full screen when you need room, and a
  readable message instead of a broken picture when the syntax is wrong.
- **Still plain Markdown.** The diagram is stored as an ordinary `mermaid`
  code block, so GitHub and GitLab render it too.

---

## Data tables

Spreadsheets that belong to the wiki: typed columns, saved views, filters and
sorting — a small database you can link from any page and query from any
agent.

![A roadmap as a data table](docs/images/table.png)

- Column types: text, long text, number, date, checkbox, select, status, user,
  link.
- Views as tabs, each with its own columns, order, widths, multi-column sort
  and `and`/`or` fil