Get AI summaries of any video or article — Sign up free
Obsidian - Canvas thumbnail

Obsidian - Canvas

Josh Plunkett·
5 min read

Based on Josh Plunkett's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Canvas creates a visual RPG planning board inside Obsidian using drag-and-link connections between nodes.

Briefing

Obsidian’s new Canvas feature turns tabletop RPG planning into a drag-and-link workflow: notes, stat blocks, images, and decision points can be arranged visually on a board, with connections that mirror how a campaign unfolds. The practical payoff is speed—Dungeon Masters can map an adventure from start to finish, then jump between sections during prep or play without constantly hunting through a long document.

The walkthrough centers on a real use case: a “getting paid” cyberpunk red module imported into Obsidian and then rebuilt as a Canvas map. Canvas nodes are created by right-clicking a folder and choosing “New canvas,” then adding content via “add note and media,” “add card,” “add web page,” or “create group.” Cards act like lightweight, embedded notes on the board. They support Obsidian-style linking, including deep links to specific headings inside a note using a hash (e.g., linking to a “Mission summary” section rather than the entire document). That lets one adventure note serve as the source of multiple board cards—useful when a module is organized by sections rather than requiring one note per chapter.

Connections between cards are drawn by dragging from one node to another, and the board can be organized with arrows and color-coded elements. The creator demonstrates building a mission flow: a phone-call hook becomes its own card, linked to the relevant section in the source note, and later decision points—like a climax at a warehouse—can branch into different cards representing player choices. Even when branches converge, the visual structure makes it easy to see where the party can go next and what information belongs to each step.

Canvas also supports richer prep artifacts. Images can be added from the Vault (PNG filtering is mentioned), then shared to players via links that trigger a “Second Window” plugin workflow on a separate screen. The transcript notes a distinction between native “Second Window” behavior and the Javelin plugin: the plugin is preferred because it better maximizes the display area for player-facing images.

For encounter prep, Canvas cards can contain TTRPG stat blocks and template-driven content. The workflow uses templates (triggered with Alt+T) to populate creatures or NPCs, and it tests encounter blocks—initially flaky, then working again for certain cases. The result is a board that not only shows narrative flow but also visually ties scenes to the specific enemies and encounter parameters needed for each chapter.

Finally, Canvas is compared with Excalidraw-based alternatives (called “Excalibur” in the transcript). Canvas is praised for cleanliness and simplicity, especially for note-centric mapping where hover previews aren’t as immediate. Excalidraw is described as more flexible for true flowchart drawing—shapes, arrow styles, and richer editing—but with more functionality hidden behind menus. The takeaway is a preference split: Canvas fits when the goal is linking and navigating notes; Excalidraw fits when the goal is diagram-first flowcharting. The creator’s wishlist is clear: more flowchart shapes, better arrow formats, and card-to-note click behavior that loads content quickly—moving Canvas closer to a full Vizio/flowchart experience while keeping its note-linking strengths.

Cornell Notes

Obsidian Canvas provides a visual board for tabletop RPG prep, letting users drag in cards, connect them with arrows, and link each card to specific sections of notes using heading deep-links (hash links). Cards behave like embedded notes, so a single adventure file can power multiple board nodes such as “Mission summary,” hooks, and decision points. Canvas can also host images and template-driven stat blocks, enabling a board that ties narrative flow to encounters and NPCs. The workflow is positioned as faster and cleaner for note-centric mapping than diagram-first tools, though Excalidraw-style options still win on shape and arrow flexibility. The feature’s value grows when campaigns become branching and need quick visual navigation during prep or play.

How does Canvas link a board card to only part of a larger note?

Canvas uses Obsidian-style deep links with a hash (#). After adding a card, the card can link to a specific heading inside a note by using the note name plus “#” followed by the heading text. In the example, the board links a card to the “Mission summary” section rather than the entire “getting paid” note, so the card content stays focused on the relevant subsection.

What makes cards central to the Canvas workflow for RPG modules?

Cards are lightweight nodes that function like their own note entries on the board. They support the same linking and rendering behavior as normal Obsidian notes, including hover previews and deep links. This allows one adventure module to be represented as a network of small, connected nodes—hooks, chapters, and decision points—without needing a separate note file for every chapter.

How are branching decisions represented visually on the Canvas board?

Decision points are built by connecting cards with arrows and then placing alternative cards off the main path. The transcript’s climax example (a warehouse) shows how different choice cards can branch from the same starting point, and how multiple branches can later converge into the same subsequent section. This makes it easy to see player options and the flow of scenes at a glance.

What role do images and the “Second Window” setup play in Canvas prep?

Images can be added from the Vault (e.g., PNGs) and then shared to players. The workflow uses links under images that trigger a Second Window plugin to open content on a separate player-facing screen. The transcript specifically favors the Javelin “Second Window” plugin because it better maximizes the image display area compared with native Second Window behavior.

How does Canvas support encounter stat blocks and templated NPCs?

Canvas cards can contain TTRPG stat blocks, and templates can populate them. The transcript mentions using Alt+T to trigger templates inside a stat-block card, then rendering a creature/NPC (e.g., a goblin) based on the template. Encounter blocks are tested as well: they initially fail in one attempt, then work again for certain cases, suggesting partial maturity but workable functionality.

Why does the transcript compare Canvas with Excalidraw-style tools, and what’s the preference logic?

Canvas is praised for being clean and easy for note-centric mapping—dragging cards, linking to headings, and navigating narrative flow. Excalidraw-style tools (Excalibur/Excalidraw) are described as more flexible for true diagramming: more control over shapes, arrow styles, and editing. The preference logic is: use Canvas when the goal is linking and navigating notes; use Excalidraw when the goal is diagram-first flowchart design.

Review Questions

  1. When would heading deep-links (hash links) be more useful than linking an entire note to a Canvas card?
  2. What specific Canvas elements (cards, arrows, groups, images) would you use to model a branching RPG decision tree?
  3. How do the transcript’s comparisons suggest choosing between Canvas and Excalidraw-style tools for different prep goals?

Key Points

  1. 1

    Canvas creates a visual RPG planning board inside Obsidian using drag-and-link connections between nodes.

  2. 2

    Cards act like embedded notes on the board and support deep links to specific headings via hash (#) links.

  3. 3

    A single adventure note can power multiple Canvas nodes by linking each card to the relevant section (e.g., “Mission summary”).

  4. 4

    Arrows and connections let DMs map start-to-finish flow and represent branching decisions that can later converge.

  5. 5

    Canvas supports adding images from the Vault and sharing them to players using a Second Window plugin workflow.

  6. 6

    Template-driven stat blocks can be placed inside cards, enabling encounter prep tied directly to scene flow.

  7. 7

    Canvas is positioned as simpler and cleaner for note-centric mapping, while Excalidraw-style tools offer more diagram flexibility (shapes and arrow formats).

Highlights

Canvas cards can deep-link into specific headings of a note using hash links, letting one module file feed many board nodes.
The board can combine narrative flow with encounter mechanics by embedding stat blocks and template-generated NPCs directly on connected cards.
A Second Window plugin workflow (Javelin) is used to maximize player-facing image display, improving usability during play.
Canvas is framed as note-linking-first and clean, while Excalidraw-style tools are framed as shape-and-arrow-first for true flowcharting.

Topics

  • Obsidian Canvas
  • Tabletop RPG Prep
  • Cards and Deep Links
  • Second Window Plugin
  • Flowchart vs Excalidraw

Mentioned

  • TTRPG
  • MD
  • PNG