tolaria.md

Tolaria stores every note as a plain Markdown file on your disk, with a YAML frontmatter block for structure. There is no database and no proprietary format, so you can open your notes in any text editor, search them from the terminal, and version them with Git. The app is open source, free, and requires no account. This matters if you care about data portability and long-term readability: your notes are not locked inside Tolaria, and they remain usable even if you stop using the app.

What a Tolaria note actually is

Each note is a .md file containing two parts:

• YAML frontmatter at the top, which holds structured data such as properties and types.
• Markdown body below it, which holds the actual content.

Because the structure lives in frontmatter rather than in a hidden store, the same file is readable both by Tolaria and by ordinary Markdown tools. The website describes this as "just files on your disk" — plain Markdown on disk, with YAML frontmatter for structure.

Can you use your notes outside Tolaria?

Yes. The storage model is designed so that outside tools work directly on the same files:

Nothing in this list requires Tolaria to be installed. The files are the source of truth, not a cache or export.

Does the rich editor change the file format?

No. Tolaria's editor is block-based and includes slash commands, wikilinks, raw Markdown, whiteboards, media previews, table navigation, and note width controls. But the site is explicit that "everything durable stays in vault files." In other words, the Notion-like editing experience is a layer on top of the same Markdown files — it does not convert your notes into a proprietary format when you save.

This is the key distinction for portability: a rich editing surface and an open storage format can coexist, and in Tolaria they do.

What this means for data ownership

• No lock-in by format. Since notes are Markdown with YAML frontmatter, you are not dependent on Tolaria to read your own writing.
• No lock-in by account. The site states the app is open source, free forever, and requires no account, so access to your files is not tied to a login.
• Version control is native. Tolaria includes a fully integrated Git client: you can commit, push, and browse history inside the app, and view version history per note. The same Git tooling you already use for code works on your notes.
• Long-term readability. Plain text files remain readable by standard tools for the foreseeable future, which is generally a safer bet than a proprietary database.

Practical checks before you commit

If portability is your main concern, verify these on your own machine:

1. Open the vault folder in your file manager and confirm you see .md files, not an opaque database file.
2. Open one note in a different editor and check that the frontmatter and body are both present and readable.
3. Run a terminal search (for example, grep -r "some phrase" your-vault/) and confirm it finds your notes.
4. Initialize or connect a Git repository to the vault and confirm Tolaria's Git panel reflects the same history.

If all four behave as described, your notes are genuinely portable and not dependent on the app.

Where the limits are

The website does not specify how Tolaria handles attachments, media, or whiteboards at the file level beyond stating that durable content stays in vault files. If your workflow depends heavily on embedded media or whiteboards, test those specific note types with an outside editor before relying on full portability. Similarly, AI features — local agents and direct model providers — operate on note context, but the site does not describe them as altering the on-disk format, so they should not affect whether your files remain readable elsewhere.

Tolaria ships with a fully integrated Git client, so you can commit, push, and browse history without leaving the app. Because every note is a plain Markdown file on disk, versioning and syncing use the same Git tooling developers already trust for code. This applies to any vault stored in a Git repository — if you don't initialize one, there's nothing for the client to track.

Why Git fits a Markdown vault

Tolaria's architecture is "just files on your disk": each note is a Markdown file with YAML frontmatter, with no database and no proprietary format. That means a vault is already a directory of text files, which is exactly what Git is designed to version. You can read the files with any editor, grep them from the terminal, or version them with Git outside the app as well.

What the built-in client does

The app exposes the core Git workflow directly in its interface:

• Commit — record a snapshot of your changes from inside Tolaria.
• Push — send commits to a remote so other devices can pull them.
• Browse history — view a rich commit history in the app.
• Per-note history — navigate the version history of a single note, not just the whole vault.
• Track changes — every change is tracked, so you can see what moved before committing.

The stated goal is that you never have to leave the app to track changes, commit, and push.

Versioning and syncing in practice

A typical flow looks like this:

1. Write or edit notes. Edits happen in the block-based editor, but everything durable is written back to vault files as Markdown.
2. Review changes. The client tracks modifications across the vault, including per-note history.
3. Commit. Create a commit describing the change set.
4. Push. Send it to your remote repository.
5. Pull on another device. Because sync runs through Git, the same remote you use for code brings the notes down elsewhere.

The key mechanism: Tolaria does not run its own sync service. Sync is Git sync. Whatever remote you configure is the transport, and the app gives you the commit/push/history interface on top of it.

What this means for you

Practical considerations

• Set up the remote first. Since syncing depends on Git, decide where your remote lives before relying on cross-device sync.
• Commit granularity is yours. The app tracks changes, but how often you commit determines how useful the history is when you want to roll something back.
• Markdown keeps you portable. If you ever stop using Tolaria, the vault remains a normal Git repository of text files — no export step required.

Tolaria is described as open source, free forever, and requiring no account. For setup specifics and current behavior, the docs live in the app repository alongside the code, so product behavior and guidance stay in sync.

Download Tolaria from the official site at tolaria.md, or get the project from GitHub. The site describes it as "open source, free forever, no account required," so you can install it and open the Getting Started vault without signing up. The docs live inside the app repo, which means the guidance you read is versioned alongside the product itself.

Download options

Tolaria is distributed through two channels mentioned on the site:

The site shows both a "Download Tolaria" action and a "Check on GitHub" link. If you only want to take notes, the download is the shorter path. If you care about how the app works or want to track changes, GitHub gives you the repo the docs are written against.

First launch: open the Getting Started vault

The documented first step is to install Tolaria and open the Getting Started vault. That vault is where the first-launch flow is explained, so it doubles as your orientation. Because every note is a Markdown file with YAML frontmatter, you can also open that vault folder in any editor, grep it from the terminal, or version it with Git — nothing is locked in a database.

Learn the model before the features

The docs suggest understanding the underlying model first: how notes, properties, types, relationships, custom views, Git, and AI fit together. This matters because Tolaria's features are connected rather than separate menus. Relationships are described as a first-class citizen, and the editor supports wikilinks with autocomplete, so a note you create in one place can be referenced and surfaced elsewhere.

Follow the workflows

Once the model makes sense, the docs walk through concrete workflows:

• Capture notes and organize the inbox
• Use wikilinks to connect notes
• Create types to give notes structure
• Push changes through the built-in Git client
• Configure AI
• Navigate long notes

Each of these builds on the previous one, so working through them in order avoids the common trap of configuring AI or Git before you have notes worth connecting.

What you can do without an account

The site states no account is required, and notes are plain Markdown files on disk. That means you can start writing immediately after install, and you can leave at any time with your files intact. The AI and Git features are additive — the core note-taking works on local files alone.

Common sticking points

• Skipping the Getting Started vault. It is the intended entry point for the first-launch flow, so starting from a blank vault means missing the explanation of how the pieces fit.
• Treating the editor as the storage layer. Everything durable stays in vault files; the block editor is a view over Markdown, not a separate format.
• Configuring AI before you have context. The AI features operate over note context, so they are more useful once you have notes and relationships in place.

Where to go next

Start at tolaria.md to download, or open the GitHub repo if you want the source and the docs together. The docs sit in the app repo by design, so product behavior, architecture, and user-facing guidance stay in sync — when something changes in the app, the documentation changes with it.

Tolaria is a local-first, open-source note-taking app that stores every note as a Markdown file with YAML frontmatter on your own disk. It positions itself as "a second brain for the AI era," is free forever, and requires no account. If you want a Notion-style block editor whose output stays as plain files you can read, grep, and version with Git, Tolaria is built for exactly that. If you need a hosted, real-time collaborative workspace, it is not that kind of tool.

The core idea: files, not a database

The architecture section states the design directly: every note is a Markdown file with YAML frontmatter. There is no database and no proprietary format. That single decision drives most of what the app is good at:

• Portability — read notes with any editor, search them from the terminal with grep, version them with Git.
• Structure without lock-in — YAML frontmatter holds properties, so metadata lives in the file rather than in an app-specific store.
• Durability — the site says "everything durable stays in vault files," meaning the vault on disk is the source of truth.

The trade-off is implicit: you manage your own files and sync. There is no mention of a hosted backend, so cross-device sync is expected to come from the tools you already use (Git, or your own file sync).

What it actually does

Editor

A block-based editor that "writes like Notion, saves as Markdown." Documented capabilities include slash commands, wikilinks with autocomplete, raw Markdown editing, whiteboards, media previews, table navigation, and note width controls. Relationships between notes are treated as a first-class feature rather than an afterthought.

Version control

Tolaria ships a fully integrated Git client. You can commit, push, and browse history inside the app, see a rich commit history, and navigate version history for a single note. This is the mechanism behind multi-device sync — the same tool developers already trust for code.

AI

Two distinct modes are described:

That split matters: if you want an assistant to edit files, use the agent path. If you only want to ask questions about your notes, the model-provider path keeps the AI read-only with respect to your vault.

Who it fits, and who it doesn't

A good fit if you:

• Want your notes as plain Markdown files you fully own.
• Already use Git and want version history without leaving the editor.
• Want AI assistance while keeping control over what gets written to disk.
• Prefer no account and no sign-up friction.

Probably not a fit if you:

• Need browser-based, real-time multiplayer editing.
• Don't want to think about files, syncing, or Git at all.
• Need a managed service with a support contract.

How to get started

1. Install — download Tolaria from the site or check it out on GitHub.
2. Open the Getting Started vault — the docs recommend starting here to understand the first-launch flow.
3. Learn the model — read how notes, properties, types, relationships, custom views, Git, and AI fit together before building a large vault.
4. Follow the workflows — capture notes, organize the inbox, use wikilinks, create types, push changes, configure AI, and navigate long notes.

The documentation lives in the app repo, so product behavior and guidance are meant to evolve together. No account is required, and the project describes itself as open source and free forever.

Tolaria splits AI use into two distinct modes: tool-backed editing through CLI coding agents (Claude Code, Codex, OpenCode, Pi, Gemini), which can write to your vault, and chat-only access through local or API model providers, which read note context but get no vault-write tools. Which one you pick depends on whether you want the AI to change files or just talk about them.

The two AI modes

The distinction matters because it is the app's main safety boundary. If you only want an AI to reason over what's in your notes, the chat mode keeps it read-only by design. If you want an agent to actually edit files, you opt into a CLI agent that has write tools.

How the agent mode works

Tolaria is built on plain Markdown files with YAML frontmatter — no database, no proprietary format. That architecture is what makes external agents viable: an agent editing your vault is just editing files on disk.

When you use a CLI coding agent, the flow is roughly:

1. Input — you invoke an agent (for example Claude Code) against your vault.
2. Action — the agent reads and writes Markdown files and frontmatter directly, using its own tooling.
3. Expected result — changes land as normal file edits, which you can then review, commit, and push through Tolaria's integrated Git client.

Because every change is tracked in Git, agent edits are reviewable and reversible like any other commit. That is the practical reason to prefer this setup over an opaque AI that mutates a hidden store.

How the chat mode works

For local or API model providers, Tolaria provides chat over your note context without vault-write tools. You supply the model (local or via a direct provider), and the conversation is grounded in your notes but cannot modify them. This is the mode to use when you want analysis, summaries, or questions answered without any risk of the AI rewriting content.

Organizing AI features

The sidebar supports custom sections, so you can group AI-related views and entry points separately from your notes. This is a layout convenience rather than a functional limit — it lets you keep agent and chat access within reach without cluttering your main note structure.

What to check before relying on this

• Agent availability — the CLI agents listed (Claude Code, Codex, OpenCode, Pi, Gemini) are external tools; you need them installed and configured, not just Tolaria.
• Model provider setup — chat mode requires you to point Tolaria at a local or API model provider. The site does not specify which providers or whether any keys are bundled, so treat provider access as your own responsibility.
• Pricing — the site states "Free forever" and "no account required," and lists "subscribe" among its signals. It does not document paid AI tiers, so don't assume AI provider costs are covered by Tolaria itself.

If your goal is AI that can safely reshape your notes, use a CLI agent and lean on Git to review the result. If your goal is AI that only reads and discusses, use the chat mode and keep your vault untouched.