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.
WYSIWYG Markdown editor.
For the docs in your git repo.
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 documentation already moved.
Your tools did not. What docs as code costs a team.
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
Told the moment somebody comments or names you
See who has changed a document since you opened it
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
Tells your AI agent how the workspace is organised
Speaks git and nothing else, so it works with what you have
GitHubGitLabBitbucketGiteaSSH keysGit LFSSubmodulesNo 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
WYSIWYG, not live preview
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.
See what it writes back
Mermaid diagrams draw themselves
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.
The comments you actually miss
Select a passage, leave a comment, reply, resolve.
And they are told, by name
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 doYou are never the last to know
and nothing ever changes under your cursor.
Somebody named you
Your machine tells you, with the sentence they wrote.
Maya Chen named you
Is the order the real problem, or the number of fields?
checkout-redesign.md · platform-docs
- Clicking it opens the document at that paragraph, not at the top.
- It keeps watching repositories you do not have open, with the window closed.
- Two at a time arrive on their own; more than that arrive together, so they stay read.
Something changed
And you did not have to go and ask.
- Every document the rest of the team has moved on is marked in the tree, with who moved it and when.
- Your own unpublished work is marked the same way, so nothing waits in a drawer you forgot about.
- It looks every thirty seconds while you are working, and every few minutes while you are not.
- All of it is read from the fetched branch, so the document on screen is still exactly what you left until you take the change.
Threads 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 isYour agent gets a briefing, not a guess
Notula writes down how the workspace works, and points Claude Code at it.
-
It writes
notula-agents.mddescribing the document types, the fields, the layout and the commands, and borrows three lines of yourCLAUDE.mdto point at it. It never overwrites what you wrote there. -
The briefing carries the rules that are invisible once broken.
Renaming a document is
notula docs move, because the comment log is filed under the document's path and a plainmvorphans every thread on it. -
There is a command line behind that - documents, types, fields,
status, all with
--json- so an agent operates the workspace instead of guessing at files. - When an agent rewrites the document you have open, the change lands in front of you instead of being clobbered.
The three lines in your CLAUDE.md
<!-- notula:begin -->
This repository is edited with Notula.
What it keeps here: @notula-agents.md
<!-- notula:end -->Your Google Meet calls write themselves in
A free Chrome extension transcribes the call and hands the file to Notula.
- Live transcription with speaker names, taken from Google Meet's own captions. No bot joins the call and no audio leaves the browser.
- A finished call becomes a Markdown file in the folder you picked, in a repository you already have. A call that comes back every week goes where it went last time.
- Notula asks before it lets the extension in, and the permission covers only the repositories you have open.
Notula for Google Meet
Free, and it works on its own. Thirty-one languages.
Add to Chrome What it does, in fullThree things happen, and none of them are your problem
MCMaya Chenrelease-process
Release process
A change reaches production in five moves, and only the last one needs somebody awake.
Describe what changed, in one sentence Add the canary step
platform-docsorigin/main
- commitAdd the canary step
- authorMaya Chen
- docs/release-process.md
- -A change reaches production in four moves, and only the last one needs somebody awake.
- +A change reaches production in five moves, and only the last one needs somebody awake.
- 1 file changed, 1 insertion(+), 1 deletion(-)
git fetch
TOTomrelease-process
- docs
- api-guidelines
- release-processMC
Maya Chen has changed this document. You are reading the version you started with. Take the change
Release process
A change reaches production in four moves, and only the last one needs somebody awake.
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.
Your documents go nowhere
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.
Where it actually is
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, signed and notarised, updating itself. It opens like any other app
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.
If you already have a Markdown editor
Typora, MarkText Better single-person writing apps. Neither has any idea what a comment is. Obsidian A better personal knowledge base. A vault is not a repository other people review. Notion, Confluence They have the review layer, and they keep the document on their own server. HackMD Has both, and asks somebody to host it. GitBook Publishes beautifully, and owns the source. VS Code Has the repository already, and nothing to say about a comment on a paragraph. Google Docs Still the reference for what reviewing a document should feel like, and the document ends up somewhere your repository is not.
Questions people ask before they point it at a work repository
What is a WYSIWYG Markdown editor?
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.
What is docs as code?
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.
Does it change my repository?
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.
Do I need to know git?
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.
Does it work with private repositories?
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.
Where do the comments live?
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.
Will it slow down on a large repository?
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.
How current is what I am looking at?
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.
Is it free?
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.
Can I keep using Claude Code in the same repository?
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.
Is there a WYSIWYG Markdown editor for Windows?
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.
Can I comment on a Markdown file in a GitHub repo?
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.
Does it render Mermaid diagrams?
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.
Is the source open?
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.
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.
The installer is not signed yet, so Windows blocks it once. The download walks you through it.
Tell us what is missing
Notula is early, and what people write in here is most of what gets built next.