Install via Docker

docker run -d \
    --name silverbullet \
    --restart unless-stopped \
    -p 127.0.0.1:3000:3000 \
    -v ./space:/space \
    ghcr.io/silverbulletmd/silverbullet:latest \
    --auth user@example.com:<password>

Or via Deno (SilverBullet is written in TypeScript / Deno):

# Install Deno
curl -fsSL https://deno.land/install.sh | sh
export PATH="$HOME/.deno/bin:$PATH"

# Install + run
deno install -A -f --name silverbullet \
    https://get.silverbullet.md
silverbullet --hostname 0.0.0.0 ./space

The ./space directory is where your notes live as plain markdown files.

Reverse proxy

# Caddy
notes.example.com {
    reverse_proxy 127.0.0.1:3000
}

The first page

Browse to the URL, log in, you're greeted with a blank wiki. Create a page (Ctrl-O or click + in the sidebar). Type some markdown.

Try a tag:

This is a note about a book I'm reading.

#books #fiction #to-finish

Hashtags are first-class — clicking one shows the tag's page with everything tagged.

Frontmatter as data

---
title: The Three-Body Problem
author: Liu Cixin
year: 2008
rating: 5
status: read
tags: [books, fiction, sci-fi]
---

Notes on the book go here.

The frontmatter is YAML; SilverBullet stores it in its index. Combined with query blocks, any page can compose a dynamic table:

```query
page where status = "read" and tags = "books"
order by rating desc
select title, author, rating, year
```

Renders inline as a table of your read books. Edit any page; the query re-renders next time you view this page. The wiki is the database.

Embedded tasks

- [ ] Email the contractor #urgent
- [ ] Buy groceries #home
- [x] Submit expense report #work

```query
task where state = "todo" and tags = "urgent"
order by lastModified desc
```

Tasks across all your pages are queryable. Build per-project todo dashboards, per-tag urgency views.

Templates

# A template page: "Templates/Book Note"
---
title: ""
author: ""
year: 0
rating: 0
status: "to-read"
tags: [books]
---

## Notes

## Quotes

When creating a new page, pick "Use template → Templates/Book Note" — the new page starts with the template's frontmatter + structure.

Daily journals

Set a daily-note template; SilverBullet auto-creates today's page on demand:

# Press Ctrl-O, type "2026-05-22" to create today's page
# Or with the daily-notes plugin enabled:

@today           # automatically resolves to 2026-05-22 page
@yesterday       # resolves to 2026-05-21
@thisweek/mon    # this week's Monday

Plugins: extend in TypeScript

SilverBullet's plugin system is unusual: plugins are TypeScript files committed to the same wiki space, loaded at runtime via Deno. The "plugin" is a page like any other.

# LIBRARIES.md  (a plugin)
```ts
silverbullet.command({
  name: "Insert Random Quote",
  key: "Ctrl-Alt-q",
  run: async () => {
    const quotes = ["Be the change", "Code is poetry", ...];
    const random = quotes[Math.floor(Math.random() * quotes.length)];
    await editor.insertAtCursor(random);
  },
});
```

Save the page; the plugin is live. New commands, custom keybindings, page indexers, query functions, dropdown widgets — all extensible.

Mobile + offline

SilverBullet has Progressive Web App support — install it on iOS / Android as if it were a native app. Sync engine keeps an offline cache; edits flush when back online.

Sync + backups

Pages live as plain markdown files in ./space/. Back up with:

  • Git (committed daily) — full history with diffs
  • Restic to S3 (see that tutorial)
  • Syncthing (see that tutorial) to peer machines

Plain files mean any markdown editor (or even Vim) can edit them directly; SilverBullet reads changes on next view.

SilverBullet vs alternatives

  • Obsidian — local-first; not self-hosted; massive plugin ecosystem. Use Obsidian for personal local notes; SilverBullet for "I want the same shape but on a server I share."
  • Trilium / TriliumNext — hierarchical notes with scripting; SQLite-backed. More features, less markdown-purist.
  • Outline (see that tutorial) — team-wiki UX; richer collaboration; no embedded queries.
  • Memos (see that tutorial) — timeline-style memos; simpler; no query blocks.
  • BookStack — wiki-shape; WYSIWYG; less power for query-driven dashboards.

When SilverBullet is the right pick

  • You want Obsidian-style backlinks + queries + plugins, but self-hosted.
  • You like the "everything is markdown in plain files" sovereignty.
  • You want to extend the tool itself in TypeScript without forking.
  • You want one wiki to be a personal knowledge base + a per-project todo system + a dashboard generator.

When it isn't

  • For team-wiki UX (rich collaboration, real-time editing), Outline is better.
  • For "I just want notes without learning a query language," Memos is simpler.
  • For local-only, Obsidian + Syncthing is lighter.