DocumentationPluginsManifestoFAQsInstallGitHub
Read Manifesto

Access all your memoriesas markdown

Open source, local-first, and sandboxed. Drop markdown into collections, run plugins to pull data in, and search across everything from one CLI.

Get startedGitHub
→→
✔ wrote ~/.dither/config.json
✔ created library at ~/.dither/library
✔ pre-downloaded model weights
✔ wrote welcome.md — open it to get started

It's just markdown.

Plugins write markdown into your library. Search indexes those files in place. There's no database, no second copy, no proprietary format — your data is plain files you can edit, grep, or move without dither. Point a collection at your existing Obsidian vault (or any folder of notes) and it shows up alongside plugin-written entries, indexed where it lives.

$ tree ~/.dither/library
~/.dither/library
├── notes/                       # you write these in your editor
│   ├── standup-tue.md
│   ├── ranking-signals.md
│   └── ideas/
│       └── grant-defaults.md
├── raindrop/                    # written by the raindrop plugin
│   ├── grug-brained-developer.md
│   └── deno-runtime-deep-dive.md
├── pocket/                      # written by the pocket plugin
│   └── how-to-backdoor-friends.md
├── feeds/hn/                    # written by the rss plugin
│   └── 2026-04-22.md
└── vault → ~/Documents/Obsidian # your obsidian vault, indexed in place
    ├── Daily/2026-05-13.md
    └── Projects/dither.md

qmd-powered

A CLI wrapper around qmd by Tobi Lütke. Hybrid lexical + semantic in one index, one file.

Deno-sandboxed plugins

Permissions are explicit and transparent. Third-party plugin code is secured through Deno.

Scheduled & watched

Cron schedules, folder watchers, activity triggers. Your index keeps itself current.

MCP-readycoming soon

Expose the index to any agent. Same tools as your CLI.

Open source. Sandboxed. Your files stay markdown. Nobody can rugpull your data.

Plugins are simple TypeScript. Sandboxed.

The runtime denies anything not granted — Deno sandboxes each plugin process. Each plugin declares the URL access list, env, and file system scopes it needs; you approve once and the daemon enforces it on every run.

plugins/bookmarks/plugin.ts
import { readInput, writeEntry } from "@dither/plugin";

const { env } = await readInput();
const res = await fetch(
  "https://api.raindrop.io/rest/v1/raindrops/0",
  { headers: { Authorization: `Bearer ${env.RAINDROP_TOKEN}` } },
);
const { items } = await res.json();

for (const b of items) {
  await writeEntry({
    collection: "bookmarks",
    body: `# ${b.title}\n\n${b.excerpt}\n\n${b.link}`,
    frontmatter: {
      id: String(b._id),
      url: b.link,
      title: b.title,
      tags: b.tags,
    },
  });
}
Community Plugins

Secure the data that belongs to you.

Plugins pull from feeds, folders, and APIs into your collections — each one a Deno script that runs only with the permissions you grant. Write your own in ~20 lines of TypeScript.

twitter

Import Twitter exports & individual tweets.

github.com/dither-plugins/twitter
pocket

Sync Pocket bookmarks to a collection.

github.com/dither-plugins/pocket
raindrop

Pull Raindrop.io bookmarks via API.

github.com/dither-plugins/raindrop
url scraper

Scrape any URL into a markdown entry.

github.com/dither-plugins/url-scraper
imessage

Index local iMessage threads.

github.com/dither-plugins/imessage
browser history

Pull Chrome / Safari / Firefox history.

github.com/dither-plugins/browser-history
slack

Index a Slack workspace via the API.

github.com/dither-plugins/slack
rss

Pull any RSS / Atom feed.

github.com/dither-plugins/rss
Request a plugin

Missing a source? Open a discussion and pitch it.

Hands-off ingest.

Run on a schedule, watch a folder, or trigger on activity. The plugin works the same way — you just don't have to think about it.

  • schedule — cron, every N minutes, or on a wall-clock.
  • watch — fs events, debounced, batched.
  • run — manual one-shot for ad-hoc ingests.
✔ Scheduled bookmarks every 1h
next run: 14:00 · last: never · job id: sch_a12f
✔ Watching ~/Inbox → notes
+ draft-202605.md · indexed (1.2 KB · 4 chunks)
+ agentic-ranking.md · indexed (0.8 KB · 2 chunks)
idle · debouncing

Your data has a center now.

Save the things you don't want to lose and find them again. One local index, designed to outlive any service or app you've used.

Manifesto

Something happened to our digital memories.

They used to belong to us. Photos on hard drives. Emails in folders. Bookmarks in browsers. You knew where things were because you put them there.

Today, our memories are scattered across a thousand services. Your thoughts live in Notion's cloud. Your conversations in Slack's servers. Your inspirations on Twitter's timeline. Your discoveries buried in Reddit's endless scroll. Each platform holds a piece of your digital self hostage, locked behind their walls, searchable only by their rules, accessible only at their pleasure.

You've become a digital tenant, paying rent to access your own memories in houses you'll never own.

Dither is a tool that works for you, not the other way around. Connect your services once. Search everything instantly. Keep control always.

Questions a skeptic asks.

›Why not just use qmd?
You can — and it's great. qmd is an excellent, agentic RAG index, and dither is honestly just a wrapper around it. I was building similar RAG applications as alternatives, decided to cut my losses, and wrapped qmd instead. dither adds the file-management layer around it: collections, plugins, scheduling, watching, and a CLI that ties it all together. The plugin runtime is where most of the work went — every plugin is a Deno subprocess started with explicit --allow-read / --allow-write / --allow-net flags derived from grants you approve at install time, scoped to the paths and hosts that plugin actually needs. Nothing in the runtime is ambient: a plugin can't read another plugin's collection, can't escape its sandbox, and can't silently broaden its grants — any change forces a reinstall and re-approval. If you don't need any of that, use qmd directly.
›Does dither send telemetry?
No. The CLI runs locally, the daemon runs locally, and plugins only reach networks they're explicitly granted.
›Can plugins exfiltrate my data?
Each plugin runs in a Deno subprocess started with explicit --allow-read / --allow-write / --allow-env / --allow-net flags derived from the grants accepted at install time. Grants are stored per plugin in ~/.dither/grants/<plugin>.json. Anything not in those flags is denied by the runtime; a plugin that requests new permissions has to be reinstalled and re-approved.
›Can I run scheduled plugins on a headless box?
Yes. `dither daemon start` spawns a detached process that runs the scheduler and watcher loops; `dither daemon stop` and `dither daemon status` manage it. For auto-start on boot, wrap it in systemd / launchd in the usual way.
›Will I get rugpulled?
No backend, no account, no telemetry. The CLI is MIT-licensed and the index is just markdown files on your disk — you can read them with anything, including without dither. The core stays free and open source forever. If paid addons ever happen (e.g. a sync service to your phone), they'll be optional and base dither won't change.
›Does it play nice with Obsidian (or my existing markdown folder)?
Yes. dither operates on plain markdown files on disk; it never moves or deletes them. Point a collection at your Obsidian vault (or any folder) and it indexes in place. Plugins can update entries if you wire them to existing files, but you can also set them up against a separate collection so nothing in your vault is ever touched.
Try it out now

Read the source code. Write a plugin in twenty lines. Open issues, ship PRs.

github.com/janniks/dither
© 2026
DocsCLIPluginsConcepts
@janniksco
MIT License