Markdown on Disk

"Rekindle edits the file in place and never owns it. The .md on disk is the truth; the editor is just a lens on it."

Edit in Place, Never Own

Rekindle's canonical store is the plainest thing possible: a Markdown file on disk. It opens the file, edits it in place, and writes it back — it never copies the note into a private format it owns. That single decision is why the file you edit in Rekindle is the same file the vault sees, the same file grep sees, the same file any other tool sees. The editor is a lens over the file, not a container that swallows it.

The File Is Valid Everywhere

Because the store is plain Markdown, the document is portable by default. The same bytes are valid in the Obsidian vault, in an essay, on the site, in Sublime, in any Markdown tool that will ever exist. There's no export step, no proprietary round-trip, no "open in Rekindle to read it." A note written in Rekindle today is readable and editable everywhere, forever — because it was never anything but a text file.

#[tauri::command]
fn write_note(path: String, contents: String) -> Result<(), String> {
    // Edit in place: write the same .md the vault, grep, and every
    // other Markdown tool already read. No private format, no ownership.
    std::fs::write(&path, contents).map_err(|e| e.to_string())
}

Nothing Sits Above the File

The discipline is that nothing is a truer master than the file. Not a database, not a cloud service, not even CodeMirror's in-memory document — that's a working copy that must be written back to the file, which remains the authority. When you want to know the real state of a note, you read the file. This is the same instinct as cwkPippa's JSONL ground truth, one domain over: the durable, plain, portable artifact is the truth, and everything else derives from it.

Code

Edit the same file everything else reads·rust

#[tauri::command]
fn read_note(path: String) -> Result<String, String> {
    std::fs::read_to_string(&path).map_err(|e| e.to_string())
}

#[tauri::command]
fn write_note(path: String, contents: String) -> Result<(), String> {
    // In place: the SAME .md the vault, grep, essays, and any Markdown
    // tool already see. No private format. No ownership. No export step.
    std::fs::write(&path, contents).map_err(|e| e.to_string())
}

// The file is the authority. The editor is a lens over it,
// not a container that swallows it into a proprietary store.

Exercise

Take a note-taking app you use and find out where a note actually lives: is it a plain file you could open in any editor, or is it inside the app's own database? Then ask what happens to that note if the app disappears tomorrow. The answer to 'can I still read it with grep' is the difference between file-canonical and own-DB-as-master.

Hint

If you can find the note as a .md (or .txt) file on disk and open it anywhere, the app is file-canonical. If the note only exists inside an app-specific database, the app owns your data — and 'export' is now a feature you depend on rather than a convenience.