Dev In The Mountain Header
A Developer In The mountains having fun

Notes That Outlive the App: Vimwiki, Org Mode, Logseq and Obsidian Compared

I've tried a lot of note-taking setups. The one rule I've kept through all of them: my notes should be plain files in a folder, and preferably Markdown. Programs come and go. The company behind the app gets bought, the sync service changes its price, the format changes in a major version. A folder of .md files opens in any editor on any computer, diffs cleanly in git, renders on GitHub, and converts with pandoc. In twenty years I'll still be able to read it.

This post compares the tools I've actually used for notes: Vimwiki in Neovim, Org mode in Doom Emacs, Logseq, and (because everyone asks) Obsidian. I judge them the way I care about: how good they are to write in, and how locked in your notes are when you want to leave.


TL;DR

VimwikiOrg mode (Doom)LogseqObsidian
File formatVimwiki syntax or MarkdownOrg (.org)Markdown (OG) / SQLite (DB)Markdown
Ease of learningβœ… Easy if you know Vim❌ Hardestβœ…βœ… Easiestβœ…βœ… Easy
Ease of daily useβœ…βœ…βš οΈ Lots to rememberβœ…βœ…βœ…βœ…
Readable without the appβœ… Yes (in Markdown mode)⚠️ Plain text, but Org syntax⚠️ Yes, but bullets everywhereβœ… Yes
Tasks & agenda⚠️ Basic checklistsβœ…βœ… Best there isβœ… Good⚠️ Via plugins
Linking & backlinks⚠️ Links, weak backlinksβœ… With org-roamβœ…βœ… Built inβœ…βœ… Built in
Lives in your editorβœ… Neovimβœ… Emacs❌ Its own app❌ Its own app
Open sourceβœ…βœ…βœ…βŒ
Biggest lock-in riskLink formatOrg syntax, org-roam IDsBlock refs, DB versionPlugin syntax
  • Want plain Markdown and live in Vim? Vimwiki in Markdown mode.
  • Want the most powerful task and planning system? Org mode, and accept that your notes are Org, not Markdown.
  • Think in outlines and like clicking around? Logseq, but stay on the file-based version.
  • Want a polished app on top of a Markdown folder? Obsidian, keeping an eye on plugin-only syntax.

Why plain files matter

"It's just Markdown" is the reason most people give for picking a note app, and it's not quite enough. A note format can be locked in three ways:

  1. Storage lock-in. The notes live in a database or a cloud service, not files you control. This is the obvious one (Notion, Evernote, OneNote).
  2. Syntax lock-in. The notes are text files, but full of syntax that only one program understands: block IDs, special link styles, query blocks, plugin markup. You can read them anywhere, but they stop working anywhere else.
  3. Structure lock-in. The value is in the links, the tags and the metadata, and that only makes sense to the program that made it. Move the files and you have a pile of disconnected pages.

Every tool in this post avoids the first one (mostly; see Logseq below). They differ a lot on the other two, and that's what the rest of this post is about.

My quick test for any note format: open a note in cat, then on GitHub, then in a different note app. How much survives?


Vimwiki

Vimwiki turns Vim or Neovim into a personal wiki. I've written about why I picked it before, and there's a cheat sheet on the site too. The short version: one keybinding opens my wiki from whatever project I'm in, I write the note, and I'm back in my code.

What it's good at

  • It's just your editor. All your Vim motions, plugins, colorscheme and muscle memory work. There's nothing new to learn except a handful of <leader>w keys.
  • Fast. It opens instantly. No Electron app, no indexing step.
  • Diary built in. <leader>w<leader>w opens today's diary page. It's a good daily-notes habit with zero setup.
  • Simple model. A folder, an index page, and links between pages. You can understand the whole thing in five minutes.

What it's not good at

  • Backlinks are weak. :VimwikiBacklinks exists, but there's no graph, no "unlinked mentions", no live sidebar.
  • Tasks are just checklists. - [ ] items toggle with Ctrl-Space, and that's about it. No due dates, no agenda across files.
  • Search is up to you. :VimwikiSearch works, but in practice I use Telescope or fzf with ripgrep over the wiki folder.

Learning it and using it

  • Learning: Easy if you already use Vim. The plugin itself is about a dozen <leader>w keys, and you can learn them in an afternoon. If you don't know Vim, the real learning curve is Vim itself, and that takes weeks.
  • Day to day: Very easy. Open the wiki, type, follow a link with Enter, go back with Backspace. There are no menus or settings to think about.

The portability catch

Out of the box, Vimwiki uses its own syntax, a mix of Markdown and MediaWiki, in .wiki files. That is lock-in: GitHub and other Markdown tools won't render it properly. If you care about portability, switch to Markdown mode before you write your first note:

vim
" ~/.config/nvim/init.vim (or the Lua equivalent)
let g:vimwiki_list = [{'path': '~/vimwiki/', 'syntax': 'markdown', 'ext': '.md'}]
lua
-- Lua / lazy.nvim
vim.g.vimwiki_list = { { path = "~/vimwiki/", syntax = "markdown", ext = ".md" } }

One more gotcha in Markdown mode: Vimwiki writes links as [Page](Page) with no .md extension. Vimwiki follows them fine, but GitHub, Obsidian and most static site generators won't. Turn on the extension so links work everywhere:

vim
let g:vimwiki_markdown_link_ext = 1

With both settings, a Vimwiki note is just a normal Markdown file. That's the best portability score in this post.


Org mode in Doom Emacs

Org mode is the reason a lot of people start using Emacs, me included. I covered my Doom setup in Emacs vs. Neovim + LazyVim, and the Org mode keybindings cheat sheet has the keys. If you're coming from Markdown, Org Mode for Markdown Users translates the syntax. Doom turns Org on by default; enable (org +roam2) in init.el for org-roam.

What it's good at

  • Tasks and planning. Nothing else comes close. TODO keywords, priorities, scheduled and deadline dates, recurring tasks, and an agenda (SPC o a) that pulls every task from every file into one view.
  • Capture. SPC X opens a capture template from anywhere in Emacs. Grab a thought, file it, and go back to what you were doing.
  • Outlining. Headings fold, move, promote and refile with a keystroke. Big documents stay manageable.
  • Tables that calculate. Org tables auto-align as you type and can hold spreadsheet formulas.
  • Literate code. Org Babel runs code blocks inside your notes and can tangle them out to config files.
  • org-roam adds backlinks, daily notes and a Zettelkasten-style workflow on top.

What it's not good at

  • It's Emacs. If you don't already use it, Org is a big commitment. Doom makes it much easier, but you still have to live in Emacs to get the value.
  • Mobile is weak. There are apps (Orgzly Revived, beorg, Plain Org), but none are as good as Emacs, and none run your agenda customisations.
  • It's easy to over-engineer. Custom keywords, a dozen capture templates, agenda views... I've spent more evenings tuning Org than taking notes in it.

Learning it and using it

  • Learning: The hardest of the four. You're learning Emacs, Org's own syntax, and then the agenda, capture and refile workflow on top. Doom helps a lot with good defaults and the which-key popup, but expect it to take weeks before it feels natural. I keep an Org mode keybindings cheat sheet for exactly this reason.
  • Day to day: Fast once you know it, but there's a lot to remember. You'll use a handful of keys every day and forget the ones you need once a month. It's also a bit harder to use than Vimwiki or Logseq, simply because it does so much more.

The portability catch

Org files are plain text, and a simple Org file reads fine in cat:

* TODO Renew domain
  DEADLINE: <2026-12-01 Tue>
* Notes on zellij
  Layouts live in ~/.config/zellij/layouts.

But Org is not Markdown. Headings are *, links are [[target][text]], code blocks are #+begin_src. GitHub renders .org files reasonably, and pandoc converts them, but very few other note apps understand them. The more Org features you use (property drawers, agenda dates, Babel, column view), the more your notes only work in Emacs.

org-roam makes this worse. It links notes by ID, not by file name:

:PROPERTIES:
:ID:       7f3c1e2a-5b4d-4c8e-9a1f-2d6e8b0c4a11
:END:
#+title: Zellij

See [[id:4a9b2c1d-8e7f-4d3c-b2a1-9f8e7d6c5b4a][terminal multiplexers]].

The SQLite database org-roam keeps is just a cache, so that's not the problem; it rebuilds from your files. The problem is that [[id:...]] links mean nothing to any other program. If you leave Emacs, every link in your knowledge base breaks.

If you want Org's tools but Markdown files, you have options, though none are perfect: md-roam teaches org-roam to read Markdown notes, and Emacs's own markdown-mode is solid for writing. You give up most of what makes Org special, though.


Logseq

Logseq is an open source outliner: every line is a block, blocks nest, and any block can be linked or embedded somewhere else. It opens to today's journal page, which makes daily notes the default way to work.

What it's good at

  • Daily journal first. You don't decide where a note goes; you write it in today's journal and tag or link it. The links do the organising.
  • Backlinks and block references. Every page shows what links to it. You can reference or embed a single block from another page, which nothing else here does as well.
  • Queries. Pull every block tagged #todo and #work into one view. Tasks with TODO/DOING/DONE and scheduled dates work well.
  • Whiteboards, PDF annotation, a graph view, and a decent plugin system.
  • Open source and local-first.

What it's not good at

  • It's an Electron app. Not your editor, no Vim motions beyond a basic mode, and it's slower than Vim or Emacs with a large graph.
  • Everything is a bullet. Great if you think in outlines, annoying if you want to write a page of prose.
  • The future is uncertain for file users (see below).

Learning it and using it

  • Learning: The easiest for most people. It's a normal GUI app: you click, type, and the mouse works. Type [[ to link a page, # for a tag, or / for a menu of commands, and it autocompletes. Today's journal page opens by itself, so you can start writing in the first minute.
  • Day to day: Easy. The one habit to learn is thinking in bullets, which takes a few days. Advanced queries use their own syntax and are noticeably harder, but you don't need them to get value from it.

The portability catch

The classic version of Logseq (now called Logseq OG) stores notes as Markdown files in journals/ and pages/. It even supports Org files. But open one in another editor and it looks like this:

- Looked at [[Zellij]] layouts today
  id:: 6721a9f3-2c4b-4e8d-9f1a-3b5c7d9e1f20
    - TODO Try the compact layout
      SCHEDULED: <2026-11-18 Wed>
- Related: ((6721a8e1-1a2b-4c3d-8e9f-0a1b2c3d4e5f))
- tags:: notes, terminal

Every line starts with - , properties use key:: value, and block references are ((uuid)). It's technically Markdown, but it only reads well in Logseq, and block references are meaningless anywhere else.

The bigger issue is the DB version. Logseq has been rebuilding the app around a local SQLite database instead of a folder of files. In April 2026 the team split the project: the file-based app continues as Logseq OG, and the database app is the main Logseq going forward. As of this writing the DB version (2.0.x) is still in beta. It drops Org file support and can write a Markdown copy of your graph to disk, but as I understand it that mirror is mostly for export and backup, not the source of truth.

For someone who wants plain files as the source of truth, that's a dealbreaker for the DB version. If you use Logseq, use Logseq OG, and keep your graph in git so you're never stuck.


Obsidian

Obsidian isn't in my daily setup, but it's the tool everyone compares against, so it belongs here. It's a polished app that works on a plain folder of Markdown files (a "vault").

What it's good at

  • Polish. Fast, good-looking, live preview, good mobile apps.
  • Backlinks, graph view, canvas, and a huge plugin ecosystem.
  • Plain Markdown on disk. Your vault is a normal folder. Config lives in a .obsidian/ folder you can ignore.
  • Free for personal and work use. Sync and Publish are paid add-ons, but you can sync the folder with git or Syncthing instead.

What it's not good at

  • Closed source. The files are yours, but the app isn't. If development stopped, your files would be fine, but the app would slowly rot.
  • Not your editor. It has a Vim mode, but it's not Vim.

Learning it and using it

  • Learning: Easy, about as easy as Logseq. It looks and behaves like most note apps, and it writes normal paragraphs instead of bullets. The learning comes later, if you start adding plugins and tuning settings.
  • Day to day: Easy. Live preview means it reads like a document while you write. The command palette (Ctrl+P) finds almost anything.

The portability catch

Obsidian defaults to [[wikilinks]], which GitHub and many tools don't render. You can switch to standard links in Settings β†’ Files and links: turn off Use [[Wikilinks]]. More important is plugin syntax: Dataview queries, Tasks plugin emoji dates, and ![[embeds]] only work inside Obsidian. Use them, and your notes slowly become Obsidian notes.

If you like Obsidian's ideas but want to stay in Neovim, obsidian.nvim and zk-nvim both work on plain Markdown folders and play well with Obsidian on the same vault.


Side by side

VimwikiOrg mode (Doom)Logseq OGObsidian
Ease of learningβœ… Easy if you know Vim❌ Hardest: Emacs + Orgβœ…βœ… GUI, easiestβœ…βœ… GUI, easy
Ease of daily useβœ…βœ… Few keys⚠️ Powerful, lots to rememberβœ…βœ… Click and typeβœ…βœ… Click and type
Writing speedβœ…βœ… It's Vimβœ…βœ… It's Emacs (Evil)⚠️ Fineβœ… Good
Long-form writingβœ…βœ…βš οΈ Bulletsβœ…
Daily notesβœ… Diaryβœ… org-roam dailies / journalβœ…βœ… Defaultβœ… Core plugin
Tasks & agenda⚠️ Checklistsβœ…βœ… Agendaβœ… Queries⚠️ Plugins
Backlinks⚠️ Command onlyβœ… org-roamβœ…βœ…βœ…βœ…
Block references❌⚠️ IDs on headingsβœ…βœ…βœ…
Mobile❌⚠️ Third-party appsβœ…βœ…βœ…
Readable in catβœ…βœ…βœ…βš οΈβœ…
Renders on GitHubβœ… (Markdown mode)βœ… Mostly⚠️⚠️ Wikilinks
Works in other note appsβœ…βœ…βŒβš οΈβœ…
Open sourceβœ…βœ…βœ…βŒ
Lock-in riskLowMedium–HighMedium (High on DB)Low–Medium

Rules I follow to keep notes portable

Whichever tool you pick, these keep your notes yours:

  1. Use standard Markdown links ([text](file.md)), with the extension. They work in more places than wikilinks.
  2. Name files sensibly. zellij-layouts.md beats 202611161430.md or a UUID when you're browsing a folder with no app around it.
  3. Avoid features that only one app understands for anything important: block refs, query blocks, plugin syntax. Use them for convenience views, not for the content itself.
  4. Put the folder in git. It's your backup, your sync, and your history. I sync mine across machines this way. (If you keep anything sensitive in your notes, see my post on SOPS + age.)
  5. Test the exit. Every so often, open your notes in something else (GitHub, another editor, glow in the terminal). If they still make sense, you're fine.

Where I've landed

For notes, Markdown wins for me. It's the format I'm confident I'll be able to read and use in any tool, years from now. Vimwiki in Markdown mode gets me that with the editor I already live in.

The tension is Org mode. For tasks and planning, the agenda and capture in Doom Emacs are better than anything I've found for Markdown, and I've accepted Org for that one job. Tasks are short-lived anyway; if I switch tools, losing some old TODO syntax isn't a big loss. Knowledge I want to keep for years goes in Markdown.

Logseq and Obsidian are both good apps, and if you don't live in Vim or Emacs I'd point you at Obsidian first. Just keep your notes in plain files, keep them in git, and don't let any one app's special syntax take over your notes.


Links

More places to find me
Mental Health
follow me on Mastodon