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.
Google Docs
for your Markdown files.
Your specs, PRDs and runbooks already live as .md in the repo,
because that is where AI agents work best. Notula gives them back everything
you left behind: comments, replies, collaboration and a document tree anyone
can use.
Your documentation already moved.
Your tools did not.
So the docs followed
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.
And everyone else lost their tools
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.
Everything you use in Google Docs,
on files that never leave your repository.
Google Docs Markdown in a code editor Notula
Comment on a passage, reply, resolve
Write without seeing any syntax
Browse documents in a tree, not a file list
Back and forward between linked docs
Usable by someone who has never opened a terminal
Files stay plain .md in your own repository
AI agents can read and edit the same files
Reviews as a normal pull request
Works with no network and no vendor account
Speaks git and nothing else, so it works with what you have
GitHub
GitLab
Bitbucket
Gitea
SSH keys
Git LFS
Submodules
No remote at all
Only the documentation, none of the code
Open a repository with thousands of source files and get a clean tree of Markdown. Folders with no documents in them never appear.
How the workspace is built
No Markdown syntax. Ever.
WYSIWYG, not live preview. No hashes, no asterisks, no table pipes, not even on the line your cursor is on. The file on disk stays ordinary Markdown.
See what it writes back
The comments you actually miss
Select a passage, leave a comment, reply, resolve. Name somebody in it and they get a notification with a link straight to the sentence.
What that does to the file
Git, without teaching git
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.
What it will never doThreads that live in the repository
A conversation is committed next to the document it is about, so it arrives with the clone and outlives every account.
- Documents stay clean. No invisible anchors, no block IDs, no HTML comments.
- Anchored by the quoted passage and its context, following the W3C Web Annotation model.
- An append-only log with a union merge driver, so two people commenting at once cannot conflict.
Navigates like a browser
Follow a link and the document opens in the same pane. Back and forward return you to exactly where you were, scroll position included.
- Every pane keeps its own trail, so a reference held open in a split is never disturbed.
- Relative links between documents resolve the way they do on the host.
- Non-Markdown link targets open read-only instead of being handed to another app.
A one-character edit stays a one-character diff
Notula writes back only what changed. Across 6,000 real documents, 96.4% of blocks survive an edit untouched.
Where the project actually isThree things happen, and none of them are your problem
Point it at a repository
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.
Write like it is a document
Headings, tables, links and images, with no syntax on screen. What lands on disk is ordinary Markdown that reviews in a normal pull request.
Everyone stays in sync
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.
Built for repositories other people are working in
Notula is a guest in someone else's worktree and behaves like one.
Scoped to its own files
Every git command carries an explicit pathspec. Notula never stages the whole worktree.
Your colleague's work is untouched
Open a repository that has someone else's uncommitted changes in it. Notula never stashes and never rewrites history.
No branches, no pull requests
Notula commits to the branch you are on and never creates or switches one. If it is protected, it says so before you edit.
Where it actually is
Early, but running. This is the honest state of each part today.
Writing WYSIWYG with no syntax on screen. Tables, diagrams, images, footnotes, code
Markdown round trip Byte-identical on 6,000 real documents, and 96.4% of blocks survive an edit untouched
Workspace and navigation Tree, quick open, full-text search, split panes, per-pane back and forward, history
Comments and review Threads, replies, mentions, suggested edits, a review inbox and desktop notifications
Git Background fetch, publishing in one sentence, conflicts as a choice between two paragraphs
macOS download Apple Silicon and Intel, updating itself. Not signed yet, so opening it takes one command
Windows download An installer for x64 and arm64, updating itself. Not signed yet, so SmartScreen asks once
Linux Not built yet
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.
Your docs are already Markdown. Make them usable.
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. On Windows, SmartScreen stops the installer once: choose More info, then Run anyway. On macOS the download is held in quarantine, so drag it to Applications and clear that once:
xattr -dr com.apple.quarantine /Applications/Notula.app