AI writes Markdown
Agents read, write and review plain .md natively. Files in the repo are where they are strongest, and where your engineers already review changes.
Docs as code, without having to be a coder. Like
Google Docs, on files that never leave the repository:
comment on a passage, reply, resolve, browse the docs in a tree, and
publish without anybody being shown a rebase
.
Free, and it stays free. No account, no server. macOS and Windows.
Your tools did not. What docs as code costs a team.
Agents read, write and review plain .md natively. Files in the repo are where they are strongest, and where your engineers already review changes.
Specs, PRDs, RFCs and runbooks left the wiki and landed next to the code. That was the right call, and nobody is moving them back.
No comments, no threads, no way to browse, no way to edit a paragraph without learning a code editor, a diff and a rebase first.
on files that never leave your repository.
Speaks git and nothing else, so it works with what you have
Open a repository with thousands of source files and get a clean tree of Markdown. Folders with no documents in them never appear.
No Markdown syntax, ever. No hashes, no asterisks, no table pipes, not even on the line your cursor is on. The file on disk stays ordinary Markdown.
A mermaid block is a picture in the document, not a wall of arrows and brackets. On disk it is still the same fenced block, so it draws on the host too.
Select a passage, leave a comment, reply, resolve.
Every version of the document is there to read and to bring back. Nobody is ever shown a rebase, a stash, or the words detached HEAD.
and nothing ever changes under your cursor.
Your machine tells you, with the sentence they wrote.
And you did not have to go and ask.
A conversation is committed next to the document it is about, so it arrives with the clone and outlives every account.
Follow a link and the document opens in the same pane. Back and forward return you to exactly where you were, scroll position included.
Notula writes back only what changed. Across 6,000 real documents, 96.4% of blocks survive an edit untouched.
Notula writes down how the workspace works, and points Claude Code at it.
notula-agents.md
describing the document
types, the fields, the layout and the commands, and borrows three
lines of your CLAUDE.md
to point at it. It never
overwrites what you wrote there.
notula docs move
, because the
comment log is filed under the document's path and a plain
mv
orphans every thread on it.
--json
- so an agent operates the workspace instead of guessing at files. The three lines in your CLAUDE.md
<!-- notula:begin -->
This repository is edited with Notula.
What it keeps here: @notula-agents.md
<!-- notula:end -->
The one your engineers already push to. Notula reads it with git ls-files, so a repository with thousands of source files opens instantly and .gitignore is respected for free.
Headings, tables, links and images, with no syntax on screen. What lands on disk is ordinary Markdown that reviews in a normal pull request.
Notula fetches in the background and tells you what arrived. Publishing is one sentence about what changed, and if two people edited the same paragraph you pick between two versions, not between conflict markers.
Notula is a guest in someone else's worktree and behaves like one.
Every git command carries an explicit pathspec. Notula never stages the whole worktree.
Open a repository that has someone else's uncommitted changes in it. Notula never stashes and never rewrites history.
Notula commits to the branch you are on and never creates or switches one. If it is protected, it says so before you edit.
There is no Notula server and no account. Documents, comments and history live as files in the repository, and the only things the app talks to are your own git remote and the releases page it updates itself from.
Early, but running. This is the honest state of each part today.
The decisions that matter are written down before the code, using GitHub Spec Kit. The source is private while the app is this young. The downloads are not, and every build carries the release notes for what changed.
One that shows you the formatted document while you type, instead of the syntax that produces it. No hashes in front of headings, no asterisks around bold, no pipes in tables. It is not the same as live preview, which puts the raw text in one pane and the rendering in another. Notula has no raw pane: the document on screen is the document, and what lands on disk is ordinary Markdown.
Keeping the documentation in the same repository as the software, in plain text, reviewed and versioned the way the code is. It solved the problem of documentation drifting away from what actually shipped, and it created a new one: only the people fluent in git could take part. Notula is an answer to the second problem, not a replacement for the first.
Only the files you edit and the comment log beside them. Every git command carries an explicit pathspec. It never stages the whole worktree, never stashes, never rewrites history, and never creates or switches a branch.
No. You open a folder, write, and publish with one sentence about what changed. Nobody is shown a rebase, a stash, or a conflict marker.
Yes. Notula drives the git already installed on your machine, so the SSH key or credential helper you already use is the one it uses. It never asks you for a password and stores no token of its own.
Committed in the repository next to the document, as an append-only log with a union merge driver. They arrive with a clone and outlive every account, and the documents themselves stay clean.
No. It asks git for the file list rather than walking the disk, keeps the Markdown, and respects .gitignore for free. Thousands of source files open as a tree of documents and nothing else.
Notula checks every thirty seconds while you are working, and every few minutes when you are not. Anything that arrived is marked with the name of whoever wrote it, and stays marked until you take it - the document on your screen never changes on its own.
Yes, and it stays free. No account, no server, no seat to pay for. If something paid ever appears it will be a service with a server behind it, like publishing a document to a public page. The app on your machine is not that.
That is the point. Notula writes a briefing describing the workspace and links it from your CLAUDE.md, so the agent knows the conventions. When it rewrites a document you have open, the change lands in front of you.
Yes. Notula ships for Windows on x64 and arm64, and for macOS on Apple Silicon and Intel, from the same page. Both update themselves from then on. Linux follows.
Not inside GitHub itself, unless you open a pull request for it. Notula adds comment threads to any Markdown file in a cloned repository - GitHub, GitLab, Bitbucket, Gitea, or no remote at all - and commits them beside the document as an append-only log. They arrive with a clone, and nothing is written into the Markdown.
Yes, drawn in the document rather than shown as a fence. On disk it stays an ordinary mermaid code block, so GitHub and Obsidian render it too.
No. Notula is a studio over files you already own, your Markdown and your repository and your git, and it keeps nothing of its own. The comment log is a plain file committed beside the documents, the workspace schema is published, and the notula command does everything the window does. Delete the app and every document and every comment is still there, readable without it.
Free, and free of accounts. macOS on Apple Silicon and Intel, Windows on x64 and arm64, both updating themselves from then on. Linux follows.
Apple Silicon. On an Intel Mac, or on Windows. 64-bit. On Windows on Arm, or on macOS.
Neither is signed yet, so the first launch takes one extra step. The download walks you through it.
Notula is early, and what people write in here is most of what gets built next.