What notes-as-commits gets you

Eight things ForkLeaf can do because your notes are commits in a repository you own. Each one below says exactly where the button is.

1–3. History, replay, and who wrote what

Open the properties panel (the panel toggle at the top right of the editor), find History, replay & who wrote what, and click it. One window, three tabs across the top:

• Changes — every commit that has touched this note, and a side-by-side diff of any two. Restore this version writes an old version back as a new commit, so nothing is lost.
• Replay — a scrubber. Drag it and the note types and untypes itself through its real revisions. The chart underneath is its length over time, so you can see where you wrote in bursts and where you deleted a section.
• Who wrote what — every paragraph with its date in the margin, shaded by age. Point at a paragraph and a card names the commit, the author, and what else that commit changed that day. That last part is the useful one: it turns “12 March” into “the day I was doing the AD engagement”.

In the command palette (⌘K / Ctrl-K) each tab has its own entry — type replay, blame or history to open straight onto it.

4. Running a code block

Write a fenced block and set its language to bash, python or javascript — either type the language after the opening fence, or pick it from the dropdown on the block itself. A Run button appears in the block’s header.

Press it. The output is written into an output block directly underneath, stamped with when it ran, and committed with the note like any other edit:

```python
print("hello world")
```

```output
— ran 2026-08-27 11:09 UTC · ok · 34ms
hello world
```

Running it again replaces that block rather than adding another. The old results are in the commit history, which is where history belongs.

Where the code runs

In a throwaway virtual machine that is created for the one run and destroyed afterwards — never on your computer, and never on the server. It does have internet access, because a runbook that cannot reach the host it is about is a text file.

5. Reviewing a note as a pull request

1. Write something, then open Propose changes in the properties panel. That puts your edits on a branch and opens a pull request.
2. Have someone comment on it — on github.com, or yourself, or a bot.
3. Back in ForkLeaf, open Review & merge this note in the properties panel.

Each comment appears against the paragraph it was written about, quoted, with a reply box. When it is settled, Squash and merge lands it as a single commit and puts you back on the main branch.

If the branch you are on has no pull request open, the panel says so rather than looking broken.

6. Linking a note to a file

A note describing a script and the script itself drift apart silently. Linking them means the note can tell you when the file has moved on.

In the properties panel, click Link a file from this repository. Filter, click a file, done — the link is inserted and the file’s current revision is recorded for you:

[[repo:scripts/scan.sh@a1b2c3d]]

You can write one by hand if you prefer — [[repo:path/to/file]] for this repository, [[repo:owner/name:path/to/file]] for another — but the picker is there because the @a1b2c3d part is a commit you have no way of knowing while writing, and it is the half that makes the feature work.

Afterwards, the Freshness section of the properties panel lists the files this note links to and whether each has changed since.

Click the link — or the file’s name in the Freshness list — to read it without leaving the note. It opens at the revision the link pinned, not at whatever the branch holds now, which is what lets you see what the note was actually written about. Markdown is rendered; anything else is shown as highlighted source, with a way through to github.com.

7. Finding notes that have gone off

The Freshness section appears in the properties panel on its own. It weighs what the note claims — version numbers, CVEs, dates, sentences hanging on the word “currently” — against how long it has been since you touched it, and against any linked file that has changed.

It never says a note is wrong. It says it is worth re-reading, and always shows why, so you can disagree at a glance. A note with nothing datable in it is never called stale however old it is: prose about how you think does not expire.

8. Publishing a page from private notes

Publishing renders a note to a single self-contained HTML page, commits it to a docs/ folder, and lets GitHub Pages serve it. Open Publish as a page in the properties panel.

If your notes repository is private

GitHub will not serve Pages from a private repository on a free plan. Nothing in ForkLeaf can change that — but it can publish somewhere else. In the publish dialog, under Pages go to:

• Click Create …-site and publish there. ForkLeaf makes a public repository named after your notes repository and points publishing at it. One click.
• Or click Use another repository and type the owner/name of a public repository you already have.

Your notes stay in the private repository. Only the rendered page is public. Leave the box empty to go back to publishing alongside your notes.

9. Capturing a web page as a source

A note that cites a page has a hole in it waiting to open: the page moves, the site is sold, the post is deleted, and the citation becomes a dead link that still looks sourced.

There are three ways in, and they all open the same dialog: the properties panel → Capture a web page as a source; the / menu in the editor → Web source; or ⌘K → Capture a web page.

1. Paste the address — the Paste button fills it from your clipboard — and press Capture, or just press Enter.
2. Two things are looked for, and each is reported as it arrives. The page’s title comes back in about a second. The archived copy can take up to a minute, because a page the Wayback Machine has never seen has to be archived before it can be linked, and the dialog says so while it waits rather than showing a bare spinner.
3. The citation is shown exactly as it will be written into the note, before it is written.
4. Press Add to this note. You can press it while the archive lookup is still running — the citation is worth having either way, and it says for itself whether an archived copy exists.

The citation is written at the end of the note as an ordinary blockquote:

> **Source** — [The article](https://example.com/article)
> Read 2026-08-27 10:04 UTC · [archived copy](https://web.archive.org/…) from 2024-03-15 12:00 UTC

If there is no archived copy, the citation says so rather than staying quiet — you should know that link may not outlive the page.

Links written this way — or typed, or pasted — open in a new tab, from the preview and from Rich view alike, so following one never takes an unsaved note with it. In Rich view, where a click also has to be able to place the cursor, Alt-click puts the caret inside the link text instead of opening it.

Hovering a link shows a small card naming the host, the page’s own title and its own one-line summary — enough to decide whether to follow it. The page is read on the server, the same way capturing reads one, so it needs you to be signed in; signed out the card still names the host and the full address. Nothing in the card is loaded from the linked site, so hovering a link never tells that site you did.

Nothing is inserted into a note that is locked; the dialog says so rather than appearing to work. See Reading a note for what locking does.