Systems Gallery¶

A system is a whole knowledge methodology you can install in one click — a ready-to-run canvas plus its step notes, written straight into your vault. Systems are the fastest way to get started with ZettelFlow: instead of a blank canvas you begin from a real workflow that already composes the cognitive actions, so a note you create through a system lands already related, cross-checked, link-suggested and maturity-scored against your own graph.

Systems ship in the unified .zftemplate format and install from the Systems room of Community — see also Community resources. Everything is offline (no network, no AI) and additive (nothing in your vault is removed).

Install a system¶

1. Open Community → Systems (ZettelFlow ribbon → Community, or the Browse systems command). Each card is a small drawing of the system's own canvas, with its level and its steps.
2. Click a card: its drawing grows into the stage, in place. Under Try it: walk the flow you walk it on the drawing — nothing is created and nothing is read from your vault.
3. Say how you will use it (Create notes is suggested only when no creation flow is set yet), read the sentence below it — exactly what is created, where, how it runs and what it replaces — and press Install. There is no confirmation dialog: the sentence was the confirmation.
4. The drawing fills the tab and the tab becomes the canvas. The notice offers Create a note and Undo, which takes the whole install back; Obsidian's Back returns to Systems, where the card now says In your vault.

Shipped systems¶

Each system is a drawn workflow on one canvas: a single entry that branches — with real edges and phase colours — to each note type it makes. Pick the flow, answer its questions, and it lands the note. Every system carries a difficulty level on its card in the Systems room — easy (a light workflow, few actions), medium (more steps and the relation/research actions), hard (the full pipeline). Start easy and grow into the richer systems; the on-creation cognitive work scales with the difficulty.

See the flows¶

Each drawing is the system's own canvas, read from its .zftemplate: the steps, their phase colours, the questions each one asks and what runs on creation. In the app the Systems room draws the same canvas itself, live from the template (#799); these pictures stay for older releases.

Systems that run code¶

A system may ship a Script or Dynamic selector action, and those carry JavaScript that ZettelFlow runs with access to your vault. Because systems install in one click from a remote catalog, the install panel says so before writing anything: it names the steps that carry code, and Install stays disabled until you tick I have looked at it and I want it. A system built from stock actions gains no extra step — there is nothing to disclose.

Conditional canvas edges (if: …) are not in that category: they are read by a pure parser with no eval, so they are never reported as executable code.

If you author one, write the code as a YAML block scalar:

  - type: script
    id: my-stamp
    hasUI: false
    code: |
      if (!zf.knowledge.ready()) return;
      content.addFrontMatter({ vault_debt: zf.knowledge.debt().score });

Weekly focus is the shipped example: it picks this week's idea from the ones that grew without your judgement, using zf.knowledge — something no stock action can do.

Author your own system¶

A system is a single .zftemplate JSON bundle: a canvas (a real .canvas) and its steps. The reference pattern (see the three pilots — zettelkasten-v2, para-v2, gtd) is fully inline: the steps live on the canvas nodes, not in external .md files, and steps is []. To contribute one:

1. Draw the flow with inline boxes. Make each step a native text canvas node whose zettelFlowSettings live in its zettelflowConfig (the Step Builder writes this when you Edit embed an inline box), and give the step an inline body template. The canvas is the system — a reader should see the methodology in the drawing.
2. One root, and branch with edges. Give the system one root: true step and connect the rest with canvas edges. Model a decision as a branch — several edges out of one step, each gated by a StepExit keyed by the edge id (when: frontmatter.<key> === "...", with a human says) — and set each step's phase so its canvas colour reads the arc at a glance. One walk makes one note (a chain merges its steps into a single note), so a choice between note types is a branch, never a chain.
3. Stay offline, and don't auto-write a judgement (§XII). On creation, auto-write only mechanical outputs: find-related, calculate-maturity, detect-orphan, find-contradiction, find-unanswered-question, extract-claims, find-sources, compare-claims. Do not auto-write the interpretive suggest-link/suggest-next-move — those are moves a human invokes, not silent writes. Never use an AI action (classify, summarize, generate-questions, challenge-idea, synthesize, suggest-connections): a shipped system runs with no network. Avoid build-time-fixed targets (attach-source, create-semantic-relation) — they are no-ops in a template.
4. Quote YAML-unsafe values. A prompt placeholder/label that starts with [[, @, {, * (or contains :) must be single-quoted, or the frontmatter fails to parse and the step is dropped.
5. Declare a difficulty. Set a top-level "difficulty": "easy" | "medium" | "hard" on the bundle so the gallery shows the right badge — easy for a light workflow, medium once you add relation/research actions, hard for the full on-creation pipeline. Optional; omit it and the badge is simply hidden.
6. Catalog it. Add the .zftemplate under docs/systems/, a sibling <id>.svg drawing of its canvas flow (plus the <id>.png rendered from it, which releases before #651 read), and a template_type: "system" row to docs/main_template.json (ref = the .zftemplate path). Since #799 the row also carries a one-line summary in both languages ({ "en": "…", "es": "…" }), and the steps and branches its canvas draws: the room groups systems by them before it fetches any template, and catalog.test.ts fails when they do not match the canvas.
7. Validate. npm test runs the validity harness. shippedSystems.test.ts + catalog.test.ts: every shipped system parses, references only registered non-AI actions, uses YAML-safe frontmatter, and resolves its canvas file-nodes to real steps — and now lints the inline nodes too (validateSystemTemplate walks each zettelflowConfig, rejecting unknown or AI actions). For a branched flow, pilotFlows.test.ts proves the shape (edges, one root), the §XII mechanical-only on-creation, no AI, the phase colours, and that each branch rehearses to exactly one outcome.
8. Publish. The fastest in-app route: build the workflow on a canvas, run ZettelFlow → Export current canvas as .zftemplate (also in the Open ZettelFlow ribbon menu), then submit it through Community's Contribute room: Share this canvas as a system → Prepare the system. That closes the loop — your system in the gallery for everyone.

README vocabulary for this page: Community Hub, Try a system before installing.