Get AI summaries of any video or article — Sign up free
My first steps implementing Zettalkasten using Obsidian.md, Data View, Excalidraw and ExcaliBrain thumbnail

My first steps implementing Zettalkasten using Obsidian.md, Data View, Excalidraw and ExcaliBrain

6 min read

Based on Zsolt's Visual Personal Knowledge Management's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Permanent notes and overview notes are distinguished using tags, with Excalibrain styling rules applied based on those tags.

Briefing

Zettelkasten in Obsidian is taking shape around a simple rule: permanent notes become the “cards,” while Excalidraw diagrams act as linked, structured thinking surfaces—connected through tags, inline Dataview fields, and carefully designed transclusions. The payoff is a navigable hierarchy of ideas (not just a web of links), where a reader can move from an overview to a specific permanent node and then into supporting comparisons like double bubble maps.

The system starts with two note types—permanent notes and overview notes—each styled and identified using only tags. Permanent notes are visually marked in Excalibrain via styling rules keyed off a “permanent note” tag, while overview notes get their own tag and styling. In practice, the Excalidraw storyboard contains inserted double bubble maps, and the red styling cues indicate which nodes are permanent. This makes the diagram feel like an index of the knowledge base rather than a free-form sketch.

Permanent note templates are intentionally minimal but structured. Each card includes a tag-based front matter, a “source” section pointing back to a specific element in a book-on-a-page, an “idea” section, a “360 view” section for related context, and an optional “related quotes” section. A key design choice is linking the note title inside the note so that when the idea section is transcluded into Excalidraw, the content reads cleanly and consistently. The “idea” section is treated as the canonical unit for transclusion—so double bubble maps can reliably pull in the important part of a permanent note.

Relationships are encoded with inline Dataview fields embedded directly in text elements. These fields define how nodes relate (for example, “because,” “use,” and “related to”), effectively acting as an ontology for the graph. When a double bubble map is built, the diagram’s text elements include Dataview fields that instruct Excalidraw/Excalibrain how to render the comparison and which permanent-note idea sections to pull in. This approach also supports hierarchy navigation: the author can “walk up” from a diagram to the underlying permanent node, then to the overview note that collects it.

Two double bubble map examples show how comparisons are assembled. One contrasts the “10,000 hour rule” with a revised learning model based on “10,000 feedback cycles,” using transclusion of the permanent notes’ idea sections into the diagram’s compare fields. Another compares a daily-workflow approach to achieving results in small steps, using embedded markdown documents and a workaround for adding Dataview fields when content is dragged into Excalidraw.

Practical navigation details matter too. The author links Excalidraw elements back to Obsidian by copying a markdown link for a selected element; adding an exclamation mark creates a link to a specific text element inside the drawing. A current limitation appears when selecting sticky notes (an error requires selecting a single element type), with a script-based workaround selecting the right element type for successful link creation.

The biggest unresolved dilemma is architectural: whether permanent notes should be markdown cards with drawings attached, or whether drawings themselves should become the Zettelkasten cards. For now, the author favors markdown as the permanent node and treats diagrams as attachments—yet still keeps relationships mirrored in Excalibrain. The hardest part so far is defining entry points and building a meaningful hierarchy of ideas that compound over time, not just linking everything together.

Cornell Notes

The system builds a Zettelkasten in Obsidian where “permanent notes” are the real knowledge cards, and Excalidraw/Excalibrain diagrams provide structured comparisons like double bubble maps. Permanent notes use tags to distinguish note types and styling, while inline Dataview fields encode relationship ontology (e.g., “because,” “use,” “related to”). The “idea” section inside each permanent note is treated as the canonical transclusion target, so diagrams reliably pull in the right content. Book references are linked down to specific elements inside Excalidraw drawings via copied markdown links, with a script workaround for sticky-note selection errors. The main open question is whether drawings should become the permanent cards or remain attachments to markdown notes.

How does the author ensure Excalibrain can tell which nodes are permanent vs overview notes?

They rely on tags as the only type marker. In Excalibrain settings under styling, a “permanent note” tag and an “overview note” tag are mapped to visual styles (including prefix emoji, border color/opacity, label length, and stroke width). In the storyboard, the double bubble map is inserted as an object, and red styling outlines indicate which ideas are permanent nodes. The hierarchy then works by linking permanent nodes into overview notes (e.g., a visual thinking framework overview note that links to “12 favorite problems”).

Why is the “idea” section treated as the transclusion target in permanent notes?

The permanent note template is structured so the “idea” section is the part that should appear inside diagrams and comparisons. The author links the note title inside the note so transcluded content reads well on the Excalidraw card. When building a double bubble map, the compare fields include Dataview/transclusion instructions that pull in the permanent note’s idea section, ensuring the diagram always shows the core claim rather than the entire card.

What role do inline Dataview fields play inside Excalidraw elements?

Inline Dataview fields embedded in bracket syntax tell Dataview/Excalibrain how to interpret the text element as a structured field and which relationship ontology to apply. These fields define how nodes connect in the graph (examples mentioned include “because,” “use,” and “related to”). In the double bubble map, the compare relationship is also driven by Dataview fields placed at the beginning of the relevant text elements, so the diagram renders the correct ontology and pulls the correct transcluded content.

How are book-on-a-page references linked to specific elements inside drawings?

The author creates element-level links by selecting a single text element or rectangle in Excalidraw, then using the Obsidian icon menu option “copy markdown link for selected element to clipboard.” They paste that link into the Obsidian note, and adding an exclamation mark in front creates a link to the specific text element inside the drawing. A limitation exists for sticky notes: selecting a sticky note can trigger an error requiring a single element selection; a script workaround selects elements by type (e.g., rectangle vs text) so “copy markdown link” works.

How does the author build double bubble maps for comparisons in two different ways?

In one approach, the diagram uses transclusion of permanent notes: the compare fields include Dataview/transclusion that pulls the idea section from two separate pages (e.g., contrasting “10,000 feedback cycles” vs the “10,000 hour rule”). In another approach, the diagram embeds markdown documents (empty note templates dragged in), then switches to markdown mode in the Excalidraw file to insert Dataview fields in the free-text area between front matter and text elements, because Dataview fields can’t be added the same way after drag-and-drop.

What is the author’s biggest design dilemma so far?

Whether Excalidraw/Excalibrain permanent notes should be markdown documents with drawings attached, or whether drawings themselves should become the Zettelkasten cards. Current practice favors markdown as the permanent node and treats the diagram as an attached illustration, even though relationships are still represented in Excalibrain. The author also flags entry-point design and building a meaningful hierarchy as the hardest part—turning a link-heavy wiki into a compounding structure of ideas.

Review Questions

  1. What specific template sections does the author include in a permanent note, and which one is consistently used as the transclusion target for diagrams?
  2. How do inline Dataview fields function as an ontology for relationships inside Excalidraw/Excalibrain?
  3. What limitation exists when copying markdown links from Excalidraw sticky notes, and what workaround is used?

Key Points

  1. 1

    Permanent notes and overview notes are distinguished using tags, with Excalibrain styling rules applied based on those tags.

  2. 2

    The permanent note template is minimal but structured: source, idea, 360 view, and optional related quotes, with the “idea” section treated as the canonical transclusion unit.

  3. 3

    Inline Dataview fields embedded in Excalidraw text elements encode relationship types (an ontology) and control how comparisons render.

  4. 4

    Double bubble maps are built by transcluding permanent-note idea sections into compare fields, ensuring diagrams display the core claim rather than entire cards.

  5. 5

    Element-level linking from Excalidraw back to Obsidian is done via “copy markdown link for selected element to clipboard,” with an exclamation mark enabling text-element targeting.

  6. 6

    A current Excalidraw limitation affects sticky notes when copying links; a script-based element-type selection workaround resolves it.

  7. 7

    The hardest open problem is defining entry points and deciding whether drawings should become the permanent Zettelkasten cards or remain attachments to markdown notes.

Highlights

Permanent notes act as the “cards,” while Excalidraw double bubble maps function as linked comparison surfaces that pull in only the permanent note’s idea section.
Inline Dataview fields inside diagram elements don’t just store metadata—they define the relationship ontology that drives how nodes connect and render.
Element-level book references are linked by copying markdown links for selected Excalidraw elements, with a sticky-note selection workaround via scripting.
The system’s biggest uncertainty is architectural: whether diagrams should be first-class Zettelkasten cards or supporting attachments to markdown permanents.

Mentioned

  • Zettelkasten