Skip to content
Back to search

aldine

MarketplaceWorks with Claude CodeGitHub

Claude Code plugins for Aldine, the self-hosted collaborative LaTeX platform.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/trahloff/Aldine with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/trahloff/Aldine'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/trahloff--aldine/badge.svg)](/listings/trahloff--aldine)

HTML

<a href="/listings/trahloff--aldine"><img src="/api/listings/trahloff--aldine/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

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:-0.13.2}
    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:-0.13.2}${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:-0.13.2}`, so a fresh copy installs the current release and nothing under a running install changes on its own. To upgrade, read the [CHANGELOG](CHANGELOG.md), back up (`deploy/backup.sh`), then:

ALDINE_VERSION=<new version> docker compose pull && docker compose up -d

To roll back, set `ALDINE_VERSION` to the previous release and run the same command. Your projects live in the `aldine-data` and `aldine-secrets` volumes and an image swap does not touch them. `:latest` still exists and points at the newest release; pinning is what lets you choose when to move. - **Pre-1.0 stability.** Versions follow SemVer with one caveat: before 1.0 a minor bump (0.3 to 0.4) may change behaviour or on-disk layout, a patch bump (0.4.0 to 0.4.1) will not. Every release is built from a commit that passed CI, and its images are booted and made to typeset a real document before `:latest` moves to them. Upgrades across a minor are not yet tested against existing data, so back up first. Watch the repo's Releases for security fixes: per [SECURITY.md](SECURITY.md), only the latest release gets them. - **The first pull is big.** TeX Live lives in the compiler image: about 1.1 GB compressed, 4.3 GB on disk. It carries TeX Live's medium scheme plus the pictures, latexextra and bibtexextra collections (pgfplots, tikz-cd, cleveref, todonotes, minted, biblatex, …), the publisher classes, and the Arabic, Persian, Cyrillic and Greek scripts; the one family it leaves out is CJK. After the first pull, starts take seconds. Ready when `curl localhost:8080/api/health` returns `{"ok":true,"name":"aldine"}`. - **Need a package it does not have?** The missing-package error in the editor names it. Two ways to get it, and project settings show which image you are on: - Add just that package. Put a `docker-compose.override.yml` next to `docker-compose.yml` that builds a derived compiler image, then `docker compose up -d --build`. `tlmgr` installs from the same dated TeX Live snapshot the release was built from, so this keeps working after the release ages: ```yaml services: compiler: image: aldine-compiler-local build: dockerfile_inline: | FROM ghcr.io/trahloff/aldine-compiler:0.13.2 RUN tlmgr install pgfplots tikz-cd ``` Bump the `FROM` tag when you bump `ALDINE_VERSION`. Compose builds the

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 21 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "$schema": "https://www.schemastore.org/claude-code-marketplace.json",
  3. "name": "aldine",
  4. "description": "Claude Code plugins for Aldine, the self-hosted collaborative LaTeX platform.",
  5. "owner": {
  6. "name": "Toby Rahloff"
  7. },
  8. "plugins": [
  9. {
  10. "name": "aldine",
  11. "source": "./claude-plugin/aldine",
  12. "description": "Claude writes, typesets and reviews LaTeX in your Aldine: repair loop, section drafting and bibliography skills over the Aldine MCP connector.",
  13. "version": "0.1.0",
  14. "author": {
  15. "name": "Toby Rahloff"
  16. },
  17. "homepage": "https://aldine.dev",
  18. "category": "productivity"
  19. }
  20. ]
  21. }
README.md · README · 622 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # [Aldine](https://aldine.dev)
  2. **Write LaTeX together. Fast, versioned, yours.**
  3. [![CI](https://github.com/trahloff/Aldine/actions/workflows/ci.yml/badge.svg)](https://github.com/trahloff/Aldine/actions/workflows/ci.yml)
  4. [![License: AGPL v3](https://img.shields.io/badge/license-AGPL--3.0-blue.svg)](LICENSE)
  5. [![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
  6. [![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?logo=buymeacoffee&logoColor=black)](https://buymeacoffee.com/trahloff)
  7. Aldine is a self-hosted, open-source collaborative LaTeX editor and an
  8. Overleaf alternative. It is slim and built for speed: real-time multi-cursor
  9. editing, every project a real git repo with branches, native Zotero, ~2s warm
  10. recompiles. Two containers and one SQLite file by default: no database server
  11. to run, nothing to babysit.
  12. **[Homepage](https://aldine.dev)** ·
  13. **[Try the live demo](https://demo.aldine.dev)** (resets nightly) ·
  14. [Quick start](#quick-start) · [How Aldine compares](#how-aldine-compares) ·
  15. [Screenshots](#screenshots) · [Self-hosting](#production-deploy) ·
  16. [Contributing](CONTRIBUTING.md)
  17. Guides on aldine.dev:
  18. [Self-hosting Overleaf (Community Edition, Server Pro) compared with Aldine](https://aldine.dev/self-hosted-overleaf/) ·
  19. [Git with Overleaf and a git-native alternative](https://aldine.dev/overleaf-git/) ·
  20. [A LaTeX MCP server for Claude](https://aldine.dev/latex-mcp/)
  21. <picture>
  22. <source media="(prefers-color-scheme: dark)" srcset="e2e/shots/editor-dark.png">
  23. <img alt="Aldine editor: LaTeX source on the left, live PDF on the right" src="e2e/shots/editor-light.png">
  24. </picture>
  25. Live collaboration, a recompile, and a SyncTeX jump, in one real recording (compile wait trimmed):
  26. ![A collaborator's edits stream in live, the PDF recompiles in about two seconds, and double-clicking the PDF jumps the editor to the source line](e2e/shots/demo.gif)
  27. > **Status:** Aldine reached 1.0 in October 2026, three months after its
  28. > first release. Within 1.x an upgrade starts on older data with no manual
  29. > step, and stable settings, MCP tools and the plugin API keep their names
  30. > until 2.0 ([docs/STABILITY.md](docs/STABILITY.md)). That is a promise about
  31. > upgrades, not a long track record. It compiles real papers daily and every
  32. > headline feature has a Playwright end-to-end test; CI runs those on every
  33. > pull request, next to typecheck, build and the integration suites. Expect
  34. > rough edges, and file issues generously.
  35. ## Features
  36. - **Bring your Overleaf projects, and take them with you**: download any Overleaf project as a ZIP,
  37. drop it on the home screen, keep writing — root file detected, first typeset
  38. automatic.
  39. - **Real-time collaboration**: CRDT-based (Yjs), multi-cursor with live
  40. presence, conflict-free by construction. Unlimited collaborators.
  41. - **Git-native with branches**: every project is a real git repository.
  42. Create branches, edit them independently, merge back from the UI. Publish a
  43. project to GitHub, GitLab, Gitea or Forgejo and a co-author can clone it and
  44. keep using VS Code; their commits come back with one Pull.
  45. - **Fast, sandboxed compiles**: TeX Live + latexmk with persistent
  46. incremental builds (~2s warm recompiles) in a no-egress container with
  47. restricted shell-escape; errors surfaced with line numbers and
  48. click-to-jump.
  49. - **GitHub/GitLab/Gitea/Forgejo sync**: import from GitHub, GitLab, Gitea or
  50. Forgejo as a project *or publish a local project to a fresh repo*, push/pull
  51. with ahead/behind indicators, branches, a conflicting pull that lists the
  52. files and keeps your version until you take the remote's, server-side
  53. autopush, and open a pull or merge request, all from the editor. gitlab.com
  54. and self-hosted GitLab, any Gitea or Forgejo instance (Codeberg included);
  55. a personal access token needs no OAuth app. A team instance can create
  56. every new project in a GitLab group automatically and push every autosave
  57. from the server.
  58. - **Native Zotero integration**: link your whole Zotero library *or a single
  59. collection*, from My Library or any of your group libraries, no premium
  60. tier required; keep a `.bib` in sync with cheap
  61. version-aware refresh, insert citations from a search panel or via `\cite{`
  62. autocomplete.
  63. - **Claude as a collaborator** (optional, `ALDINE_MCP=1`): Aldine has a
  64. built-in MCP server. Connect your
  65. instance to claude.ai, Claude Desktop, Cowork or Claude Code over MCP and
  66. Claude edits, typesets and shows the PDF in the chat (inline on claude.ai,
  67. Claude Desktop and Cowork; a signed link elsewhere); every change is a git
  68. commit authored "Claude" with a review-and-revert toast in the editor.
  69. Setup, reachability and the security model: [docs/AGENT_API.md](docs/AGENT_API.md).
  70. ![Claude edits the open document, adds a section, typesets, and History lists its commits with a review prompt](e2e/shots/agent-demo.gif)
  71. <details>
  72. <summary><strong>Everything else</strong>: visual editor, review mode, AI error fix, SyncTeX, plugins, auth, scaling…</summary>
  73. - **Visual editing mode**: LaTeX renders as formatted text while the source
  74. stays authoritative and **byte-stable** (it never rewrites source you didn't
  75. deliberately edit). WYSIWYG math (click a formula to edit it in a MathLive
  76. popover; a formula MathLive would rewrite, such as one with a `\label`,
  77. alignment, a comment or a line break inside, opens as source), editable
  78. tables, inline tracked changes from review suggestions,
  79. paste-rich-text-to-LaTeX, image-previewing figure chips, and an outline.
  80. From the keyboard, Ctrl+Enter (⌘Enter on a Mac) with the caret in a
  81. formula's or a table's source opens its editor. Cursor-reveal shows raw
  82. source under the caret, including a remote collaborator's. Switch between
  83. Source and Visual in the toolbar or the command palette (⌘K); a `.tex` file
  84. opens as source until you pick Visual, and your browser remembers the last
  85. choice.
  86. - **Review mode**: select text and leave an anchored, threaded comment;
  87. optionally attach a suggested replacement the author accepts with one click.
  88. Comments highlight in the editor, resolve/reopen, and track edits.
  89. - **AI error fix** (optional, BYO key): on a failed typeset, get a
  90. plain-English diagnosis and one-click fixes. Set `OPENROUTER_API_KEY`,
  91. `OPENAI_API_KEY`, or `ANTHROPIC_API_KEY` on the server to enable (that
  92. precedence order if several are set; `ALDINE_AI_MODEL` overrides the model).
  93. With `ALDINE_AI_AUTOFIX=1` a typeset someone asks for that fails runs the
  94. 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
  95. Aldine is a 100% AI-free editor.
  96. - **Find and cite papers without leaving the editor**: search the literature
  97. by title or author (OpenAlex), or paste a DOI / arXiv id — one click appends
  98. the BibTeX and inserts the `\cite` (no account, free public APIs).
  99. - **SyncTeX both ways**: double-click the PDF to jump to source; ⌘J to jump
  100. the PDF to your cursor, with a highlight flash.
  101. - **Plugin system**: manifest + ES module plugins add sidebar panels and
  102. write into the editor. Zotero, references, and AI-fix ship as plugins;
  103. write your own.
  104. - **Templates & import**: article, IAC conference paper, beamer and
  105. report/thesis; a template for each publisher class the compiler's TeX Live
  106. carries (Elsevier, IEEE, ACM, REVTeX, LNCS and more: 15 in the published
  107. images); 25 official conference and journal kits (NeurIPS, ICML, ACL, CVPR,
  108. Springer Nature, Wiley, …) downloaded from the publisher when you create
  109. the project; plus your group's own templates from any git repository
  110. (`TEMPLATE_REPOS`). Or import an existing project from an Overleaf ZIP.
  111. - **Editor niceties**: auto-typeset on idle, live whole-document word count,
  112. spellcheck, Vim keybindings, PDF zoom + download, selectable PDF text with
  113. Find (⌘F in the preview), drag-drop figure upload,
  114. previews of images and PDFs from the file tree, plain-English error
  115. hints + raw log, command palette (⌘K / Ctrl+K), Format document
  116. (latexindent on the compile service, Shift+Alt+F / ⌥⇧F; indentation only,
  117. one undo step).
  118. - **Search and replace across the project**: every text file on the branch,
  119. open or not, with match case, whole word and regular expressions; Replace
  120. all changes open documents live for everyone and lands as one commit.
  121. - **Multi-user auth** (optional): set `AUTH_ENABLED=1` for login, per-project
  122. ownership, and sharing (invite-only or link). Google, GitHub & ORCID SSO,
  123. your own OpenID Connect provider (Keycloak, Authentik, Authelia, Pocket ID;
  124. [docs/OIDC.md](docs/OIDC.md)), or email/password (scrypt-hashed, revocable HTTP-only-cookie sessions);
  125. `ALDINE_SSO_ONLY=1` disables passwords entirely. Off by default
  126. (single-tenant); the collab socket is access-checked.
  127. `ALDINE_ADMIN_EMAILS=you@example.org` opens `/admin`: accounts, active
  128. users (7 / 30 days, editing now), projects, compile time, and per account
  129. disable, confirm address, password reset and delete. Never project content.
  130. No compose file passes this variable through; add it under `environment:`
  131. of the `app` service. `ALDINE_SIGNUP=approval` keeps every new account,
  132. password or single sign-on, waiting until an administrator approves it on
  133. `/admin`; with email set up, the administrators get a mail when one starts
  134. waiting.
  135. - **Your name next to ours**: `ALDINE_INSTANCE_NAME`, a logo, your website and
  136. a support contact (`ALDINE_SUPPORT`) show who runs the instance and whom to
  137. ask for help, beside Aldine's own name, on the sign-in page, the project
  138. list, About and the browser tab; administrators can change the support
  139. contact on `/admin`. [docs/BRANDING.md](docs/BRANDING.md).
  140. - **Scales when you need it**: one SQLite file by default; set
  141. `DATABASE_URL` for Postgres and `REDIS_URL` for shared rate limits and
  142. cross-node collab events. One app node is still the supported topology;
  143. [docs/SCALING.md](docs/SCALING.md) says exactly what is and isn't built.
  144. - **Apple-style UI**: system fonts, hairline borders, light & dark mode,
  145. keyboard-first (⌘S typeset, ⌘J jump, ⌘K command palette).
  146. </details>
  147. ## Quick start
  148. No clone, no build: save this as `docker-compose.yml` and run `docker compose up -d`:
  149. ```yaml
  150. name: aldine
  151. services:
  152. app:
  153. image: ghcr.io/trahloff/aldine-app:${ALDINE_VERSION:-1.15.0}
  154. ports:
  155. - "8080:3000"
  156. volumes:
  157. - aldine-data:/data
  158. - aldine-secrets:/secrets
  159. networks: [frontend, backend]
  160. init: true
  161. restart: unless-stopped
  162. compiler:
  163. image: ghcr.io/trahloff/aldine-compiler:${ALDINE_VERSION:-1.15.0}${ALDINE_TEXLIVE:-}
  164. volumes:
  165. - aldine-data:/data
  166. # The compiler runs untrusted LaTeX. Keep this block.
  167. networks: [backend]
  168. mem_limit: 2g
  169. pids_limit: 256
  170. cap_drop: [ALL]
  171. security_opt: [no-new-privileges]
  172. init: true
  173. restart: unless-stopped
  174. networks:
  175. frontend: {}
  176. backend:
  177. internal: true # no route to the internet
  178. volumes:
  179. aldine-data:
  180. aldine-secrets:
  181. ```
  182. Open http://localhost:8080. That's it. Projects live in the `aldine-data`
  183. volume, and everything else (auth, SSO, AI fix, email) is opt-in via
  184. environment variables when you want it.
  185. That is equivalent to the repo-root `docker-compose.yml` (same services,
  186. images and sandbox settings), so a clone works identically: `git clone https://github.com/trahloff/Aldine && cd Aldine &&
  187. docker compose up -d`. Keep the `name: aldine` line wherever you save it: it
  188. fixes the volume names, which is what lets you switch compose files later and
  189. what `deploy/backup.sh` looks for.
  190. - **You are pinned to a version.** The block above says
  191. `${ALDINE_VERSION:-1.15.0}`, so a fresh copy installs the current release and
  192. nothing under a running install changes on its own. To upgrade, read the
  193. [CHANGELOG](CHANGELOG.md), back up (`deploy/backup.sh`), write the new
  194. version into a `.env` file next to `docker-compose.yml`, then pull:
  195. # .env
  196. ALDINE_VERSION=<new version>
  197. docker compose pull && docker compose up -d
  198. Compose reads `.env` on every call, so a later `up` stays on that version.
  199. A prefix (`ALDINE_VERSION=… docker compose pull && docker compose up -d`)
  200. reaches only the first command, and `up` starts the old version again. To
  201. roll back, put the previous release in `.env` and run the same two
  202. commands. Your projects live in the `aldine-data` and `aldine-secrets`
  203. volumes and an image swap does not touch them. `:latest` still exists and
  204. points at the newest release; pinning is what lets you choose when to move.
  205. - **Stability.** Versions follow SemVer. A 1.x release starts on data from
  206. an earlier 1.x, or from 0.14 or later, with no manual step, and nothing
  207. covered is removed before 2.0. Every release is built from a commit that
  208. passed CI, and its images are booted and made to typeset a real document
  209. before `:latest` moves to them. Before that, it is also started on volumes
  210. left by the previous release and by 0.14.4, on the JSON store and on
  211. Postgres, and the projects, comments, shares and tokens have to survive.
  212. Back up first anyway. Watch the repo's Releases for security fixes: per
  213. [SECURITY.md](SECURITY.md), only the latest release gets them. Which data,
  214. settings and APIs every 1.x keeps working, and how each promise is
  215. checked, is in [docs/STABILITY.md](docs/STABILITY.md).
  216. - **The first pull is big.** TeX Live lives in the compiler image: about
  217. 2.4 GB to download, about 5 GB on disk. It carries TeX Live's medium scheme plus
  218. the pictures, latexextra and bibtexextra collections (pgfplots, tikz-cd,
  219. cleveref, todonotes, minted, biblatex, …), the publisher classes, and the
  220. Arabic, Persian, Cyrillic and Greek scripts; the one family it leaves out
  221. is CJK. After the first pull, starts take
  222. seconds. Ready when `curl localhost:8080/api/health` returns
  223. `{"ok":true,"name":"aldine"}`.
  224. - **Need a package it does not have?** The missing-package error in the
  225. editor names it. Two ways to get it, and project settings show which
  226. image you are on:
  227. - Add just that package. Put a `docker-compose.override.yml` next to
  228. `docker-compose.yml` that builds a derived compiler image, then
  229. `docker compose up -d --build`. `tlmgr` installs from the same dated
  230. TeX Live snapshot the release was built from, so this keeps working
  231. after the release ages:
  232. ```yaml
  233. services:
  234. compiler:
  235. image: aldine-compiler-local
  236. build:
  237. dockerfile_inline: |
  238. FROM ghcr.io/trahloff/aldine-compiler:1.15.0
  239. RUN tlmgr install pgfplots tikz-cd
  240. ```
  241. Bump the `FROM` tag when you bump `ALDINE_VERSION`. Compose builds the
  242. image on your machine, so this works for `arm64` servers as well.
  243. - Get everything. Every release from 0.4.0 also ships all of TeX Live as
  244. `-full` (about 2.8 GB compressed, 9 GB on disk; CJK is only here). Add
  245. `ALDINE_TEXLIVE=-full` next to `ALDINE_VERSION` and pull again.
  246. - **Port 8080 taken?** Change the left side of `ports:`; with
  247. `docker-compose.full.yml`, set `ALDINE_PORT=8081` in `.env` instead.
  248. - **On a NAS**, with the same compiler sandbox:
  249. - CasaOS and ZimaOS: import [`deploy/casaos/docker-compose.yml`](deploy/casaos/docker-compose.yml) under App Store → Custom Install.
  250. - TrueNAS 24.10 and later: [docs/TRUENAS.md](docs/TRUENAS.md) (Install via YAML).
  251. - Unraid: [docs/UNRAID.md](docs/UNRAID.md) (Compose Manager Plus).
  252. - **Everything beyond the minimum**: building from source (latest `main`,
  253. not a release), auth/SSO/AI/email options, TLS, Postgres/Redis. All of it
  254. lives in [`docker-compose.full.yml`](docker-compose.full.yml), which carries
  255. the same compiler sandbox and the same volumes, so you can switch without
  256. losing data: `docker compose -f docker-compose.full.yml up -d --build`.
  257. The first build installs TeX Live into the compiler image; expect 20–60
  258. minutes (the `tlmgr install` step is most of it), then seconds per start.
  259. `ALDINE_TEXLIVE_SCHEME=full` builds the all-of-TeX-Live variant instead.
  260. ## How Aldine compares
  261. | | Aldine | Overleaf CE (self-hosted) | git + VS Code + LaTeX Workshop |
  262. |---|---|---|---|
  263. | Deploy | 2 containers, `docker compose up` | Overleaf Toolkit; `sharelatex`, `mongo` and `redis` containers ([source][ol-req]) | n/a (local) |
  264. | Real-time collaboration | ✅ CRDT, unlimited collaborators | ✅ ([source][ol-repo]) | ❌ (async via git) |
  265. | Review comments / suggested edits | ✅ | ❌ commenting and track changes are Server Pro only ([source][ol-cmp]) | PR reviews |
  266. | Git branches from the UI | ✅ projects *are* git repos | ❌ git integration is Server Pro only ([source][ol-cmp]) | ✅ (it *is* git) |
  267. | GitHub/GitLab/Gitea sync + PRs/MRs from the editor | ✅ | Overleaf documents GitHub synchronization as "a premium feature for Overleaf Cloud users" ([source][ol-gitdocs]); absent from its on-premises comparison ([source][ol-cmp]) | ✅ natively |
  268. | Zotero | Whole library **or one collection** | Overleaf lists Zotero among the third-party integrations of its cloud platform ([source][ol-onprem]); absent from its on-premises comparison ([source][ol-cmp]) | Via Better BibTeX auto-export |
  269. | Warm recompile | ~2s (persistent latexmk cache) | Not measured | Local |
  270. | Templates gallery | 4 starter templates, one per publisher class in the compiler's TeX Live (15 in the published images), 25 conference and journal kits fetched from the publisher, plus your own from git repositories | ❌ private template management is Server Pro only ([source][ol-cmp]) | CTAN / your own |
  271. | Package coverage | TeX Live medium + pictures, latexextra, bibtexextra, publisher classes, most scripts by default (about 5 GB on disk); any extra with one `tlmgr install` line; **all of TeX Live** with `ALDINE_TEXLIVE=-full` | Minimal TeX Live in the image; full with `tlmgr install scheme-full` ([source][ol-tl]) | Whatever you install |
  272. | Rich-text / visual editing | ✅ byte-stable, WYSIWYG math, editable tables, review suggestions shown inline (accept/dismiss) | ✅ Visual Editor; its code is in the open-source repository ([source][ol-visual]) | ❌ |
  273. | Maturity | Young: 1.0 since October 2026, first release July 2026 | Overleaf dates from 2011 ([source][ol-about]) | Very mature |
  274. | License | AGPL-3.0 | AGPL-3.0 ([source][ol-repo]) | MIT/varies |
  275. [ol-cmp]: https://docs.overleaf.com/on-premises/welcome/server-pro-vs.-community-edition
  276. [ol-req]: https://docs.overleaf.com/on-premises/getting-started/requirements/software-requirements
  277. [ol-tl]: https://docs.overleaf.com/on-premises/installation/upgrading-tex-live
  278. [ol-repo]: https://github.com/overleaf/overleaf
  279. [ol-about]: https://www.overleaf.com/about
  280. [ol-gitdocs]: https://docs.overleaf.com/integrations-and-add-ons/git-integration-and-github-synchronization
  281. [ol-onprem]: https://www.overleaf.com/for/enterprises/when-to-use-overleaf-on-premises-vs-in-the-cloud
  282. [ol-visual]: https://github.com/overleaf/overleaf/tree/main/services/web/frontend/js/features/source-editor/extensions/visual
  283. If Overleaf CE fits you, use it; it's good software. Aldine exists for people
  284. who want review comments with suggested edits, git and Zotero without paid
  285. tiers, in a deployment they can hold in their head.
  286. Every Overleaf CE cell except "Not measured" links to the Overleaf page it
  287. was checked against on 2026-10-12. For GitHub synchronization and Zotero we
  288. found no Overleaf page that states them for the on-premises editions, so
  289. those cells quote what Overleaf does say. A longer, dated version of this
  290. comparison is at
  291. [aldine.dev/self-hosted-overleaf](https://aldine.dev/self-hosted-overleaf/).
  292. ## Screenshots
  293. <picture>
  294. <source media="(prefers-color-scheme: dark)" srcset="e2e/shots/home-dark.png">
  295. <img alt="Home: the project list as a shelf of first pages, each from the project's last typeset" src="e2e/shots/home-light.png">
  296. </picture>
  297. *Home: every project shows page 1 of its last typeset. Search, sort, or start a new one from a template, a ZIP or a git host.*
  298. <picture>
  299. <source media="(prefers-color-scheme: dark)" srcset="e2e/shots/visual-dark.png">
  300. <img alt="Visual editing mode: the same LaTeX paper rendered as formatted text with typeset math, next to the live PDF" src="e2e/shots/visual-light.png">
  301. </picture>
  302. *Visual editing: the source rendered as formatted text, byte-stable, with math and tables editable in place. Switch with Source/Visual in the toolbar.*
  303. | | |
  304. |---|---|
  305. | <picture><source media="(prefers-color-scheme: dark)" srcset="e2e/shots/review-dark.png"><img alt="Review mode: anchored comment threads with suggested edits" src="e2e/shots/review-light.png"></picture> | <picture><source media="(prefers-color-scheme: dark)" srcset="e2e/shots/branches-dark.png"><img alt="Branch menu on a project" src="e2e/shots/branches-light.png"></picture> |
  306. | Review mode: threads + one-click suggestions | Branches: create, switch, merge from the UI |
  307. | <picture><source media="(prefers-color-scheme: dark)" srcset="e2e/shots/zotero-dark.png"><img alt="Zotero panel: search your library and insert citations" src="e2e/shots/zotero-light.png"></picture> | <picture><source media="(prefers-color-scheme: dark)" srcset="e2e/shots/history-dark.png"><img alt="History view with checkpoints and diffs" src="e2e/shots/history-light.png"></picture> |
  308. | Zotero: cite from your library or collection | History: auto-checkpoints, named checkpoints, diffs |
  309. ## Development
  310. ```bash
  311. npm install
  312. npm run dev:server # API + collab on :3000
  313. npm run dev:web # Vite on :5173 (proxies to :3000)
  314. docker build -t aldine-compiler apps/compiler
  315. docker run -d -p 4020:4020 -v $PWD/.data:/data aldine-compiler
  316. ```
  317. ### Tests
  318. ```bash
  319. npm run typecheck -w apps/web && npm run test -w apps/web # tsc + vitest
  320. npm run test:github -w apps/server # GitHub-sync integration
  321. npm run test:gitlab -w apps/server # GitLab-sync integration
  322. npm run test:gitea -w apps/server # Gitea/Forgejo-sync integration
  323. npm run test:db -w apps/server # datastore conformance
  324. ```
  325. End-to-end (Playwright; covers compile, collab, branches, plugins, Zotero). The
  326. suite starts its own app on :3100 but not the compiler, and it runs against
  327. `.data-e2e`, so the compiler has to point at that directory or every compile
  328. test fails against a healthy-looking compiler:
  329. ```bash
  330. npx playwright install chromium
  331. DATA_DIR=$(pwd)/.data-e2e PORT=4020 node apps/compiler/server.js & # or a container on the same dir
  332. npm run test:e2e
  333. ALDINE_URL=http://localhost:8080 npm run test:e2e # against a running compose stack instead
  334. ```
  335. ## Production deploy
  336. Settings live in a `.env` file next to the compose files, so every later
  337. `docker compose` call picks them up. Give each comment its own line: anything
  338. after a value becomes part of the value, and `AUTH_ENABLED=1 multi-user login`
  339. is not `1`, so auth silently stays off.
  340. ```dotenv
  341. # app on loopback only; your reverse proxy fronts it
  342. ALDINE_APP_BIND=127.0.0.1
  343. # absolute URL of the app, used in OAuth callbacks, password-reset links and
  344. # the PDF links the MCP connector hands out. Give it a path to serve Aldine
  345. # under a prefix (https://server/internal/aldine); the Claude connector URL
  346. # is <ALDINE_PUBLIC_URL>/mcp
  347. ALDINE_PUBLIC_URL=https://aldine.example.com
  348. # signs the connector's 15-minute PDF links; generated into META_DIR when
  349. # unset — set it explicitly when several nodes do not share that volume.
  350. # At least 32 characters (`openssl rand -base64 32`); shorter values refuse to boot
  351. ALDINE_SIGNING_SECRET=
  352. # MCP endpoint for Claude (docs/AGENT_API.md); needs AUTH_ENABLED=1 or ALDINE_MCP_TOKEN
  353. ALDINE_MCP=
  354. # static bearer for /mcp with auth off (single-tenant); ignored when AUTH_ENABLED=1
  355. ALDINE_MCP_TOKEN=
  356. # closed = only OAuth clients an administrator added (npm run oauth:add-client);
  357. # open (default) = any client can register itself
  358. ALDINE_OAUTH_REGISTRATION=
  359. # Everything below is optional and off unless set.
  360. # multi-user login, ownership and sharing (unset = single-tenant)
  361. AUTH_ENABLED=1
  362. # Google SSO
  363. GOOGLE_OAUTH_CLIENT_ID=
  364. GOOGLE_OAUTH_CLIENT_SECRET=
  365. # GitHub SSO
  366. GITHUB_LOGIN_CLIENT_ID=
  367. GITHUB_LOGIN_CLIENT_SECRET=
  368. # ORCID SSO: a Public API client (orcid.org/developer-tools, HTTPS callback
  369. # <ALDINE_PUBLIC_URL>/api/auth/oauth/orcid/callback); ORCID_SANDBOX=1 for sandbox.orcid.org
  370. ORCID_CLIENT_ID=
  371. ORCID_CLIENT_SECRET=
  372. # OpenID Connect SSO (Keycloak, Authentik, Authelia, Pocket ID, …): redirect URI
  373. # <ALDINE_PUBLIC_URL>/api/auth/oauth/oidc/callback; every option in docs/OIDC.md
  374. OIDC_ISSUER=
  375. OIDC_CLIENT_ID=
  376. OIDC_CLIENT_SECRET=
  377. OIDC_LABEL=
  378. OIDC_ALLOWED_GROUPS=
  379. # Profile pictures from SSO (OIDC `picture`, Google, GitHub) are fetched and served
  380. # by Aldine itself; 0 keeps initials and fetches nothing
  381. # ALDINE_AVATARS=0
  382. # Who runs this instance, shown beside Aldine (docs/BRANDING.md); the logo
  383. # paths are inside the container
  384. ALDINE_INSTANCE_NAME=
  385. ALDINE_INSTANCE_LOGO=
  386. ALDINE_INSTANCE_LOGO_DARK=
  387. ALDINE_INSTANCE_URL=
  388. ALDINE_SUPPORT=
  389. # GitHub repo sync: a separate OAuth app with repo scope; GITHUB_URL points
  390. # it at a GitHub Enterprise Server (PAT connect works without these)
  391. # GITHUB_URL=https://github.com
  392. GITHUB_CLIENT_ID=
  393. GITHUB_CLIENT_SECRET=
  394. # GitLab sync (gitlab.com or self-hosted); PAT connect works without these
  395. GITLAB_URL=https://gitlab.com
  396. GITLAB_CLIENT_ID=
  397. GITLAB_CLIENT_SECRET=
  398. # Gitea / Forgejo sync: users paste a token and their instance URL; this one starts the field
  399. # GITEA_URL=https://git.example.edu
  400. # REMOTE_PROVIDERS=github,gitlab,gitea # hide a provider by leaving it out
  401. # Optional: every new project is also created on GitLab in this group (service
  402. # account PAT with scope api and Owner on the group). Off unless both are set.
  403. GITLAB_TOKEN=
  404. GITLAB_DEFAULT_GROUP=
  405. # GITLAB_DEFAULT_VISIBILITY=private # or internal | public
  406. # AUTOPUSH_DEBOUNCE_MS=30000
  407. # AI error fix, bring your own key
  408. OPENROUTER_API_KEY=
  409. # password-reset email: SMTP, or SES_FROM + AWS_REGION instead
  410. SMTP_HOST=
  411. SMTP_PORT=587
  412. SMTP_USER=
  413. SMTP_PASS=
  414. SMTP_FROM=
  415. # error tracking, and which instance the errors came from
  416. SENTRY_DSN=
  417. SENTRY_ENVIRONMENT=production
  418. # Templates from your own git repositories (see templates/README.md)
  419. # TEMPLATE_REPOS='[{"id":"lab","label":"Lab templates","url":"https://gitlab.example.org/latex/templates.git","tokenEnv":"TEMPLATE_REPO_LAB_TOKEN"}]'
  420. # TEMPLATE_REPO_LAB_TOKEN=
  421. ```
  422. ```bash
  423. # Behind your existing reverse proxy (nginx, Traefik, …), the usual setup. The
  424. # prod overlay trusts proxy headers, sets secure cookies, and rotates logs;
  425. # point your proxy at 127.0.0.1:8080.
  426. # Sample nginx vhost (WebSocket + body-size gotchas handled): deploy/nginx.conf
  427. docker compose -f docker-compose.full.yml -f deploy/docker-compose.prod.yml \
  428. up -d --build
  429. # …or, if nothing else owns ports 80/443, add the bundled Caddy for
  430. # zero-config HTTPS: append `--profile tls` and set ALDINE_DOMAIN in .env.
  431. # Back up the data + secrets volumes (and the bundled Postgres, if you use it):
  432. deploy/backup.sh aldine-backup.tar.gz
  433. # Restore, after stopping the stack with `docker compose down` (with Postgres,
  434. # start the database alone first: deploy/README.md, "Restore"):
  435. # deploy/restore.sh aldine-backup.tar.gz
  436. ```
  437. Every variable Aldine reads is listed in
  438. [deploy/README.md](deploy/README.md#all-configuration).
  439. **Isolation & limits.** The compiler runs on an internal-only Docker network
  440. (no internet egress), drops all Linux capabilities, and is bounded on CPU /
  441. memory / PIDs; LaTeX compiles with **restricted shell-escape** (whitelist
  442. only) and `openin_any=p`. Per-client rate limits guard login, AI, and
  443. reference lookups; compiles are concurrency-capped, with optional per-user
  444. compile quotas (`ALDINE_COMPILE_QUOTA_MIN`) if you host for a group.
  445. See [deploy/README.md](deploy/README.md) for the full single-VPS runbook
  446. (nginx/Traefik/Caddy ingress, backups, SSO setup, Postgres/Redis, every
  447. config variable),
  448. [deploy/aws](deploy/aws) for a Terraform/Fargate deployment, and
  449. [SECURITY.md](SECURITY.md) for the threat model and how to report
  450. vulnerabilities.
  451. ## Architecture
  452. ```
  453. ┌────────────┐ HTTP/WS ┌──────────────────────────────┐
  454. │ Browser │ ───────────► │ app (Node 22) │
  455. │ React + │ │ Fastify API + Hocuspocus │
  456. │ CM6 + Yjs │ │ git repos + worktrees │
  457. └────────────┘ └──────────┬───────────────────┘
  458. │ shared volume /data
  459. ┌──────────▼───────────────────┐
  460. │ compiler (TeX Live medium) │
  461. │ latexmk wrapper, sandboxed │
  462. └──────────────────────────────┘
  463. ```
  464. - One Yjs document per file per branch (`project::branch::path`), persisted
  465. straight to the git worktree with debounced writes and auto-commits.
  466. - Branches are git worktrees, so every branch is editable concurrently.
  467. - Compile output stays inside the project tree (`.aldine-out/`, kept out of
  468. git history) which keeps latexmk's incremental cache warm. When leftover
  469. build files break a document whose source is fine, **Recompile from
  470. scratch** (the menu beside Typeset, or the command palette) deletes the
  471. main document's `.aldine-out/` and typesets it again.
  472. ### Data & storage
  473. Two separate concerns, behind two seams:
  474. - **Project files**: real git repos + worktrees on disk (`store.ts`). This is
  475. what gives you branches and history.
  476. - **Relational/metadata**: users, sessions, project metadata, review comments,
  477. and usage go through the `DataStore` interface (`db/`). Three backends:
  478. - **SQLite** (default): one file, `META_DIR/aldine.db`, through the
  479. `node:sqlite` module built into Node, so no dependency. On its first
  480. start it copies the JSON files of an earlier release and leaves them as
  481. they were.
  482. - **JSON files** (`ALDINE_DATASTORE=json`): the default before 1.7, kept
  483. for anyone who wants plain files.
  484. - **Postgres** (set `DATABASE_URL`): the horizontally-scalable backend, and
  485. the prerequisite for ever running multiple app nodes. `pg` is an optional
  486. dependency; the same conformance suite runs against all three.
  487. For how this scales past one box (and what the remaining walls are), see
  488. [docs/SCALING.md](docs/SCALING.md).
  489. ### Commit authors
  490. Commits Aldine makes for a signed-in person (checkpoints, merges, reverts,
  491. publish and pull, switching branch) are authored under the account name with
  492. a made-up address, `jane.smith@aldine.local`; Aldine itself is the committer.
  493. GitHub, GitLab, Gitea and Forgejo link a commit to a profile by its author
  494. email, so that address links to nobody. To have the commits show up on your
  495. profile, set **Commit email** in Account settings to an address your git
  496. host knows. The host's noreply address keeps your own private:
  497. `12345+name@users.noreply.github.com` on GitHub (Settings → Emails),
  498. `12345-name@users.noreply.gitlab.com` on GitLab. Only the commits your own
  499. requests make carry it, the author name stays your account name, and
  500. nobody else sees the address in Aldine. Claude's commits keep their own
  501. identity. Leave the field empty to go back to the `@aldine.local` address.
  502. ## Plugins
  503. A plugin is a folder in `plugins/`:
  504. ```
  505. plugins/hello/
  506. ├── manifest.json # { "id": "hello", "name": "Hello", "version": "1.0.0", "entry": "index.js" }
  507. └── index.js # export default { activate(aldine) { ... } }
  508. ```
  509. The `aldine` API exposes `ui.registerSidebarPanel` (with an optional
  510. `onShow`, called each time the panel comes into view), `ui.showPanel` (select
  511. one of the plugin's own panels), `ui.registerCommand` (a palette command),
  512. `ui.confirm` (a question in the app's own dialog),
  513. `editor.insertAtCursor`, `editor.insertCitation`, `project` context,
  514. `compile()`, `toast()`, and `fetch()`. See
  515. `plugins/zotero` for a complete example.
  516. ## Templates
  517. A template is a folder with a `template.json` and the files to start from;
  518. the shipped ones live in `templates/`. A group that keeps its own thesis,
  519. poster or report templates puts the same layout in any git repository
  520. (GitHub, GitLab, Gitea, a bare repo over https), lists it in
  521. `TEMPLATE_REPOS`, and the templates appear in the gallery under the
  522. repository's name, refreshed on an interval or with "Refresh templates", with
  523. `{{PROJECT_NAME}}`, `{{AUTHOR}}`, `{{DATE}}` and `{{YEAR}}` filled in on
  524. create. With accounts on, each person can also add repositories only they
  525. see, such as letters with their own address, under Account settings →
  526. Personal templates. Layout, manifest fields, placeholders and
  527. private-repository tokens: [templates/README.md](templates/README.md).
  528. ## License
  529. Copyright (C) 2026 Tobias Rahloff.
  530. [AGPL-3.0](LICENSE): self-host freely; if you offer a modified Aldine as a
  531. service, share your changes. Third-party plugins interact with Aldine over its
  532. plugin API and may use any license. Each folder under `templates/` carries its
  533. own `LICENSE` and states it in `template.json` (the gallery shows it on the
  534. tile): the generic templates are MIT, and `templates/iac-paper` is LPPL-1.3c,
  535. the customary license for a LaTeX class file. Venue templates are generated
  536. from the classes installed in the compiler image, with the license `tlmgr`
  537. reports. Venue kits are downloaded from the publisher when a project is
  538. created, and their tile links the publisher's terms instead of naming a
  539. license. No publisher file is stored in this repository. Overleaf is a
  540. trademark of its owner. Claude, Zotero, GitHub, GitLab and other names are
  541. trademarks of their respective owners. Aldine is an independent project, not
  542. affiliated with or endorsed by any of them.
  543. Two things stated plainly, because finding them out later feels like a
  544. bait-and-switch. **A hosted Aldine service is planned**, and contributions are
  545. accepted under a [CLA](CLA.md) that permits relicensing, so a commercially
  546. licensed edition is possible in future. What will not change: the self-hosted
  547. edition stays AGPL-3.0, and no feature that works today moves behind a paid
  548. tier. The name is handled separately in [TRADEMARK.md](TRADEMARK.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.