Veterans who can show an Honorable Discharge receive 50% off. See pricing

Ravenwood Software
Blog

Why I Built Muninn, a Local-First Markdown Notebook in Rust

I pushed the first commit of Muninn a little after midnight on November 7. Nine days and eighteen releases later, it's where I plan everything I run. My Projects and Ops board lives in it, right next to the Markdown notes it points at.

It's a folder of .md files. That's the whole database. Muninn just remembers the links.

How it started

The honest answer isn't very dramatic. The OpenCode team at Anomaly released Rune, their native Rust UI framework, and I wanted to try it. I like that team. I still reach for OpenCode a lot, and when they ship something new I want to know how it feels to build with. Reading the README wasn't going to tell me that. Building something real would.

I needed a project, and I already had one sitting in front of me. My notes were split between Obsidian and Notion. Some things lived in a vault on disk. Some lived in a workspace in the cloud. Project boards were in one place, the notes they referenced were in the other, and I was the glue.

So that night I started a notebook. Twenty-three minutes after midnight, the first commit. Five minutes later, v0.1.0 was published.

The name comes from Odin's two ravens. Huginn is thought. Muninn is memory. Everything I build under Ravenwood Software ends up with a raven somewhere in it, so this one picked itself.

Why I kept going

Trying Rune got me started. A few other things kept me going.

  • I'm not fond of plugin ecosystems. I said it on X when Kanban landed: I'm not fond of the whole plugin ecosystem. I wanted the features I actually use built in. More on that below.
  • I wanted plain files my local agents can read. I run local agents against my own notes. If the vault is just Markdown on disk, every one of them can read it with no special integration.
  • I wanted to own the tool that sits on my machine all day. Same instinct as Raven. Keep it small enough to read. No telemetry. No account.

By November 9 I had moved my whole Ravenwood setup over. My profile and ops docs came from the old Obsidian vault, project notes came out of a Notion export, and Notion became the archive. Muninn has been the source of truth since.

A little personal context. Chronic migraines mean I do a lot of my work at night. I wanted a calm place to write and plan in those hours. One app, my files, my theme. That's most of what this is.

What Muninn is

Muninn is a local-first Markdown notebook with a wikilink graph, a whiteboard and a Kanban board. No database. No lock-in.

  • You pick a folder. Every note is a .md file you can open in any editor, diff, back up or keep in Git.
  • Links work the way you'd expect: [[Note]], [[Note|alias]], [[Note#heading]]. Click a link to a note that doesn't exist yet and Muninn creates it.
  • Five modes: Write, Read, Graph, Board and Kanban, on Ctrl+1 through Ctrl+5.
  • It's free and open source under MIT. There's no Muninn account to make.

No plugins, no MCP. On purpose.

Muninn won't have plugins. Not now, not later. A feature is either built in or it isn't in Muninn at all.

That's not me being stubborn for the fun of it. A plugin is someone else's code running inside the app that holds all my notes. Obsidian says it plainly in its own plugin security docs. It can't reliably restrict plugins to specific permissions, so community plugins can access files on your computer, connect to the internet and install additional programs. Their advice for sensitive data is an independent security audit of a plugin before you use it. Be honest. Almost nobody does that.

And the Obsidian plugin scene is ridiculous. Thousands of plugins, a lot of them overlapping, some of them no longer maintained, and every one is another thing to trust and keep updated. I'd rather spend my time writing in my notes app than maintaining it.

So the things I actually use, like Kanban, the whiteboard and the graph, are built in and reviewed like every other line of code. If you need something Muninn doesn't do, your vault is still plain Markdown. (I don’t really use Kanban all that much……but PO’s like the look of em.)

The same goes for MCP. No MCP server either. I even had an issue open to build one into Muninn, and I closed it. It's literally all .md files, so adding an MCP server just to help tools find Markdown files felt silly. I can point an agent at the directory and it works with them perfectly fine. And if I go for a web build later, an MCP server is one more small security hole to worry about, at least in my mind.

The stack

This is the part I actually wanted to learn, so here's the deep dive.

Rust, and strict about it. The toolchain is pinned to Rust 1.99.1 in rust-toolchain.toml, edition 2024. unsafe_code is set to forbid across the whole workspace. If something needs unsafe, it needs to live upstream, not in my notebook.

Rune for the UI. Rune is GPU rendered and native Rust. It isn't on crates.io yet, so I pin a git revision of rune, rune-kit for Markdown, rune-theme-opencode and rune-fx. The graph effects run through a compositor on wgpu. Pinning is a trade-off. I get stability, and I give up getting fixes for free. With a pre-release framework that's the right call and I update occasionally after an audit or they add something I made an issue for.

One Rune feature mattered more than I expected. It can render headless, so the repo produces PNG snapshots of scenes and an agent can check the UI without opening a window. That turned out to be a big deal for how this got built.

A workspace with hard walls. It's split into small crates:

  • muninn-core: vault scan, wikilinks, backlinks, search, and the Board and Kanban file formats. No UI code.
  • muninn-graph: deterministic force layout and camera math.
  • muninn-sync: plans and moves vault bytes for GitHub, Google Drive and Tailscale.
  • muninn-ui: state, Rune views, shortcuts and autosave.
  • muninn-i18n: every user-facing string as a typed key.
  • muninn-app: the muninn binary, the CLI and the FX compositor.
  • xtask: checks, layer rules, i18n lint and snapshots.

xtask layers fails CI if one Muninn crate starts depending on another it isn't allowed to. The core can't quietly start depending on the UI. I don't have to remember that rule. CI does.

The file is the source of truth. There's no database and no background index writer. Muninn scans the vault on open and re-indexes after saves. Boards are plain .excalidraw files. Kanban boards are Markdown notes in a format written to be compatible with Obsidian Kanban files, so if you're coming from Obsidian your boards aren't trapped.

Sync is optional and manual. You press Sync Now. It can push to a GitHub branch, a Google Drive app data folder, or another machine on your tailnet through tailscale serve. Tokens live in the OS credential store, never in settings.json. If you never set it up, your notes never leave your machine.

It follows Omarchy. I daily-drive Omarchy, so Muninn follows the Omarchy theme by default. System, Dark and Light are there too, plus Reduce motion.

Releases are tag driven. I push a tag and GitHub Actions builds everything: Linux x86_64 and aarch64 tarballs, amd64 and arm64 .debs, a macOS Apple Silicon tarball and a Windows zip, plus checksums with a Sigstore bundle.

The site is Astro, built into an nginx image and hosted on my own GoForge platform at muninn.ravenwoodsoftware.dev.

How it actually got built

I steered agents through the majority of this build. I'm not going to pretend otherwise.

That's how eighteen releases happen in nine days. As of today the repo has 367 commits and 138 merged pull requests. I did not type most of that code. What I did was decide what Muninn should be, write the issues, set the rules, and review what came back. Foreman, one of my agents, does the engineering. Gatekeeper, another one, reviews every PR. Nothing merges without my OK.

The guardrails are what make that work. Forbidding unsafe, the layer rules in xtask, the headless snapshots. None of that is there to look serious. It's there so an agent can't quietly do the wrong thing, and so I can verify the right thing without taking anyone's word for it, including the agent's. Steering is still work. It's just a different kind.

What it can do today

The latest release is v0.8.6, out November 15.

  • Write and Read with [[ completion, a backlinks rail, find, back and forward history, and link rewriting when you rename a note.
  • Graph, global and local, pannable and zoomable. There are graph effects presets (Classic, Electric, Off) at Subtle, Balanced or Intense intensity. Deleted notes burn out of the graph and the sidebar. Is that necessary? No. Unnecessary razzle dazzle. I like it anyway.
  • Board, a whiteboard that edits .excalidraw files in place. Shapes, arrows, freehand, text and colors. As of v0.8.6 you can double-click a shape to label it and link any element to a note.
  • Kanban inside a note. Lanes, cards, dates, tags, archive and filters, with Board, List and Table views. All of it is Markdown.
  • Paste as Markdown. Rich text pastes as Markdown, and pasting a URL over selected text makes a link.
  • Focus mode hides the chrome, dims the other paragraphs and keeps the line you're typing on centered.
  • Safe saves. Autosave after about half a second idle, atomic writes, crash recovery, and a trash with undo.
  • Desktop bits. An optional tray icon, start at login, a global shortcut and a single-instance guard.
  • Headless checks. --check and --list-links run against a vault without opening the app.
  • Accessibility and translation groundwork. An accessibility pass landed, and every string now runs through the i18n catalog. It's English only for now.

It's been feature complete since v0.8.0, when Kanban shipped on November 13. Since then it's been polish, i18n and little stuff.

What's rough

I'd rather say this up front.

  • I only run it on Omarchy. The Mac and Windows builds exist, but they need people to actually use them.
  • macOS is Apple Silicon only for now.
  • The builds aren't code signed, so your OS will probably complain the first time.
  • Rune is pre-release, so I'm pinned to a revision and some things wait on upstream.

What's next

  • Per-note lock for v0.9.0. Encrypt a single note with its own password, using AES-256-GCM and Argon2id. The core prototype and design doc shipped in v0.8.4. It isn't wired into the UI yet.
  • Right-to-left text. That one is waiting on upstream Rune.
  • On hold: proper installers with an in-app updater, and a web version. Both are good ideas. Neither beats making the desktop app solid first.

Try it

The release assets have been downloaded 522 times so far. I'm counting every one of those as a tester, because that's what this stage is.

  • Grab a build from the download page or GitHub releases.
  • If you use mise, this is how I install it: mise use -g github:raythurman2386/muninn@0.8.6
  • On a Raspberry Pi or another arm64 Debian or Ubuntu box, use the arm64 .deb. The x86_64 build needs glibc 2.43 or newer.
  • Or build from source: cargo run -p muninn-app -- --vault ~/notes

If you're on a Mac or Windows, I especially want to hear from you. Open an issue on GitHub and tell me what broke.

Get early access

I started Muninn to try a framework from a team I like. I kept going because I wanted one calm place for my notes, as plain files I own, with nothing on my machine I can't read.

If that sounds like what you want too, join the waitlist. That's where early access and release news go first. Your notes are files. Muninn remembers the links.

Need a map or app built? Book a free consultation.