Aldine

Aldine

Write LaTeX together. Fast, versioned, yours.

Aldine is a self-hosted, open-source collaborative LaTeX editor and an Overleaf alternative. It is slim and built for speed: real-time multi-cursor editing, every project a real git repo with branches, native Zotero, ~2s warm recompiles. Two containers and one SQLite file by default: no database server to run, nothing to babysit.

[Homepage](https://aldine.dev) · [Try the live demo](https://demo.aldine.dev) (resets nightly) · Quick start · How Aldine compares · Screenshots · Self-hosting · Contributing

Guides on aldine.dev: Self-hosting Overleaf (Community Edition, Server Pro) compared with Aldine · Git with Overleaf and a git-native alternative · A LaTeX MCP server for Claude

Live collaboration, a recompile, and a SyncTeX jump, in one real recording (compile wait trimmed):

Status: Aldine reached 1.0 in October 2026, three months after its

first release. Within 1.x an upgrade starts on older data with no manual

step, and stable settings, MCP tools and the plugin API keep their names

until 2.0 (docs/STABILITY.md). That is a promise about

upgrades, not a long track record. It compiles real papers daily and every

headline feature has a Playwright end-to-end test; CI runs those on every

pull request, next to typecheck, build and the integration suites. Expect

rough edges, and file issues generously.

Features

• Bring your Overleaf projects, and take them with you: download any Overleaf project as a ZIP, drop it on the home screen, keep writing — root file detected, first typeset automatic.
• Real-time collaboration: CRDT-based (Yjs), multi-cursor with live presence, conflict-free by construction. Unlimited collaborators.
• Git-native with branches: every project is a real git repository. Create branches, edit them independently, merge back from the UI. Publish a project to GitHub, GitLab, Gitea or Forgejo and a co-author can clone it and keep using VS Code; their commits come back with one Pull.
• Fast, sandboxed compiles: TeX Live + latexmk with persistent incremental builds (~2s warm recompiles) in a no-egress container with restricted shell-escape; errors surfaced with line numbers and click-to-jump.
• GitHub/GitLab/Gitea/Forgejo sync: import from GitHub, GitLab, Gitea or Forgejo as a project *or publish a local project to a fresh repo*, push/pull with ahead/behind indicators, branches, a conflicting pull that lists the files and keeps your version until you take the remote's, server-side autopush, and open a pull or merge request, all from the editor. gitlab.com and self-hosted GitLab, any Gitea or Forgejo instance (Codeberg included); a personal access token needs no OAuth app. A team instance can create every new project in a GitLab group automatically and push every autosave from the server.
• Native Zotero integration: link your whole Zotero library *or a single collection*, from My Library or any of your group libraries, no premium tier required; keep a .bib in sync with cheap version-aware refresh, insert citations from a search panel or via \cite{ autocomplete.
• Claude as a collaborator (optional, ALDINE_MCP=1): Aldine has a built-in MCP server. Connect your instance to claude.ai, Claude Desktop, Cowork or Claude Code over MCP and Claude edits, typesets and shows the PDF in the chat (inline on claude.ai, Claude Desktop and Cowork; a signed link elsewhere); every change is a git commit authored "Claude" with a review-and-revert toast in the editor. Setup, reachability and the security model: docs/AGENT_API.md.

Everything else : visual editor, review mode, AI error fix, SyncTeX, plugins, auth, scaling…

• Visual editing mode: LaTeX renders as formatted text while the source stays authoritative and byte-stable (it never rewrites source you didn't deliberately edit). WYSIWYG math (click a formula to edit it in a MathLive popover; a formula MathLive would rewrite, such as one with a \label, alignment, a comment or a line break inside, opens as source), editable tables, inline tracked changes from review suggestions, paste-rich-text-to-LaTeX, image-previewing figure chips, and an outline. From the keyboard, Ctrl+Enter (⌘Enter on a Mac) with the caret in a formula's or a table's source opens its editor. Cursor-reveal shows raw source under the caret, including a remote collaborator's. Switch between Source and Visual in the toolbar or the command palette (⌘K); a .tex file opens as source until you pick Visual, and your browser remembers the last choice.
• Review mode: select text and leave an anchored, threaded comment; optionally attach a suggested replacement the author accepts with one click. Comments highlight in the editor, resolve/reopen, and track edits.
• AI error fix (optional, BYO key): on a failed typeset, get a plain-English diagnosis and one-click fixes. Set OPENROUTER_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY on the server to enable (that precedence order if several are set; ALDINE_AI_MODEL overrides the model). With ALDINE_AI_AUTOFIX=1 a typeset someone asks for that fails runs the diagnosis without a click, once per new error (auto-typeset runs never do). The key stays server-side and never reaches the browser. Unset the key and Aldine is a 100% AI-free editor.
• Find and cite papers without leaving the editor: search the literature by title or author (OpenAlex), or paste a DOI / arXiv id — one click appends the BibTeX and inserts the \cite (no account, free public APIs).
• SyncTeX both ways: double-click the PDF to jump to source; ⌘J to jump the PDF to your cursor, with a highlight flash.
• Plugin system: manifest + ES module plugins add sidebar panels and write into the editor. Zotero, references, and AI-fix ship as plugins; write your own.
• Templates & import: article, IAC conference paper, beamer and report/thesis; a template for each publisher class the compiler's TeX Live carries (Elsevier, IEEE, ACM, REVTeX, LNCS and more: 15 in the published images); 25 official conference and journal kits (NeurIPS, ICML, ACL, CVPR, Springer Nature, Wiley, …) downloaded from the publisher when you create the project; plus your group's own templates from any git repository (TEMPLATE_REPOS). Or import an existing project from an Overleaf ZIP.
• Editor niceties: auto-typeset on idle, live whole-document word count, spellcheck, Vim keybindings, PDF zoom + download, selectable PDF text with Find (⌘F in the preview), drag-drop figure upload, previews of images and PDFs from the file tree, plain-English error hints + raw log, command palette (⌘K / Ctrl+K).
• Search and replace across the project: every text file on the branch, open or not, with match case, whole word and regular expressions; Replace all changes open documents live for everyone and lands as one commit.
• Multi-user auth (optional): set AUTH_ENABLED=1 for login, per-project ownership, and sharing (invite-only or link). Google, GitHub & ORCID SSO, your own OpenID Connect provider (Keycloak, Authentik, Authelia, Pocket ID; docs/OIDC.md), or email/password (scrypt-hashed, revocable HTTP-only-cookie sessions); ALDINE_SSO_ONLY=1 disables passwords entirely. Off by default (single-tenant); the collab socket is access-checked. ALDINE_ADMIN_EMAILS=you@example.org opens /admin: accounts, active users (7 / 30 days, editing now), projects, compile time, and per account disable, confirm address, password reset and delete. Never project content. No compose file passes this variable through; add it under environment: of the app service. ALDINE_SIGNUP=approval keeps every new account, password or single sign-on, waiting until an administrator approves it on /admin; with email set up, the administrators get a mail when one starts waiting.
• Scales when you need it: one SQLite file by default; set DATABASE_URL for Postgres and REDIS_URL for shared rate limits and cross-node collab events. One app node is still the supported topology; docs/SCALING.md says exactly what is and isn't built.
• Apple-style UI: system fonts, hairline borders, light & dark mode, keyboard-first (⌘S typeset, ⌘J jump, ⌘K command palette).

Quick start

No clone, no build: save this as docker-compose.yml and run docker compose up -d:

name: aldine

services: app: image: ghcr.io/trahloff/aldine-app:${ALDINE_VERSION:-1.8.0} ports:

• "8080:3000" volumes:
• aldine-data:/data
• aldine-secrets:/secrets networks: [frontend, backend] init: true restart: unless-stopped

compiler: image: ghcr.io/trahloff/aldine-compiler:${ALDINE_VERSION:-1.8.0}${ALDINE_TEXLIVE:-} volumes:

• aldine-data:/data

The compiler runs untrusted LaTeX. Keep this block.

networks: [backend] mem_limit: 2g pids_limit: 256 cap_drop: [ALL] security_opt: [no-new-privileges] init: true restart: unless-stopped

networks: frontend: {} backend: internal: true # no route to the internet

volumes: aldine-data: aldine-secrets:

Open http://localhost:8080. That's it. Projects live in the aldine-data volume, and everything else (auth, SSO, AI fix, email) is opt-in via environment variables when you want it.

That is equivalent to the repo-root docker-compose.yml (same services, images and sandbox settings), so a clone works identically: git clone https://github.com/trahloff/Aldine && cd Aldine && docker compose up -d. Keep the name: aldine line wherever you save it: it fixes the volume names, which is what lets you switch compose files later and what deploy/backup.sh looks for.

• You are pinned to a version. The block above says ${ALDINE_VERSION:-1.8.0}, so a fresh copy installs the current release and nothing under a running install changes on its own. To upgrade, read the CHANGELOG, back up (deploy/backup.sh), write the new version into a .env file next to docker-compose.yml, then pull:

.env

ALDINE_VERSION=

docker compose pull && docker compose up -d

Compose reads .env on every call, so a later up stays on that version. A prefix (ALDINE_VERSION=… docker compose pull && docker compose up -d) reaches only the first command, and up starts the old version again. To roll back, put the previous release in .env and run the same two commands. Your projects live in the `