Obsidian Dice Roller: not just for gaming

TL;DR

Dice Roller turns Obsidian notes into interactive randomness tools using simple dice formulas like 1d20 with live preview and re-roll support.

Briefing Cornell Notes

Briefing

A lightweight Obsidian plugin called Dice Roller can turn plain notes into interactive randomness engines—useful far beyond tabletop gaming. After installation, typing a simple “dice” command (e.g., “dice” followed by a formula like 1d20) produces roll results with live preview, hover details, and clickable re-rolls. That same mechanism supports modifiers (addition, multiplication), special dice systems (percentile dice, FUDGE/Fate dice), and advanced mechanics such as advantage/disadvantage (keep highest/lowest), exploding dice, and success-counting thresholds.

The practical takeaway is that Dice Roller’s syntax isn’t limited to rolling numbers for games. It can drive randomness inside Obsidian’s own data structures—dataview fields, tables, tags, and blocks—so it can generate prompts, triage work, or help people decide what to do next without manually scanning long lists. In one example, a note defines dataview parameters like priority (1–5) and urgency (1–5). Dice Roller then combines them into a single metric by multiplying fields (e.g., priority * urgency), optionally adding constants or randomness (like 1d10) so the combined score varies across rolls. The plugin can also roll on markdown tables, selecting a row from a predefined set of items such as performance-test heuristics.

That table-rolling approach becomes a creative workflow tool. Instead of preparing every possible test or idea, the user maintains structured markdown tables (e.g., problems to investigate, principles of testing) and uses Dice Roller to randomly pick a few items during a project cycle. Hovering reveals the associated descriptions, and the output can be tailored using column selectors—such as using a pipe to show only the “problem” column or only the “description” column. The randomness stays grounded because the table entries are curated for the topic at hand, acting as a “creative reboot” rather than pure chance.

Dice Roller also supports tag-based retrieval, effectively functioning like a lightweight inbox or processing queue. By using a tag selector (e.g., hashtag TVZ) with a “link” option, it can return links to notes tagged for follow-up, or randomly surface one item from that set—reducing the mental burden of “401 things to process.”

Finally, Dice Roller can return random blocks from within notes, including code blocks, headings, images, and lists. For example, it can pick a single list item from a page of fiction-writing “forms” (using listitem), or restrict results to a specific heading level (like heading-2) so re-rolls stay within a chosen section. A related option, “dice mod,” changes how results display—returning only the final value instead of showing the underlying formula.

Overall, Dice Roller reframes playfulness as a productivity technique: it injects structured randomness into knowledge management, turning curated tables, tags, and note sections into on-demand prompts that can break creative or planning deadlocks.

Cornell Notes

Dice Roller for Obsidian uses a simple “dice” syntax to generate random results, starting with classic tabletop formulas like 1d20. What makes it broadly useful is that the same randomness can be applied inside Obsidian data: dataview fields, markdown tables, tags, and even specific blocks such as list items or heading levels. Curated tables let users “roll” prompts for what to test next, while tag-based rolls can surface one item from a processing queue (e.g., notes tagged TVZ). Output can be customized to show only certain columns or only the final computed value using “dice mod.” This turns structured note-taking into an improvisation tool for both work and creative work.

How does Dice Roller generate a roll, and what does “1d20” mean in practice?

After enabling the plugin, typing a dice formula like 1d20 creates a virtual 20-sided die roll. With live preview on, the result renders after leaving the line, and hovering shows details such as “rolled a 1d20.” The roll is clickable for re-rolling, and the example demonstrates changing outcomes (e.g., rolling 5, then re-rolling to get 18).

What kinds of dice mechanics can be expressed beyond basic ranges?

Dice Roller supports modifiers and special dice formats. Examples include adding constants (1d20 + 4) and multiplying (1d20 * 2). It can roll percentile dice using 1d percentage (values from 1 to 100). It also supports game-specific dice like FUDGE/Fate dice, which use a six-sided die layout with blank, positive, and negative faces. Advanced mechanics include keeping the highest/lowest from multiple d20 rolls (advantage/disadvantage), exploding dice (rolling extra dice when a threshold like a 20 occurs), and success counting (e.g., treating d10 results over 6 as successes and rolling multiple times to count how many succeed).

How can Dice Roller combine dataview fields into a single randomized metric?

In a note using dataview parameters, fields like priority (1–5) and urgency (1–5) can be combined using Dice Roller formulas. Multiplying them (priority * urgency) produces a combined score. The output can also incorporate constants (adding a number) and randomness (e.g., adding 1d10) so the metric shifts across rolls. The hover preview shows the underlying field values used in the calculation.

Why are random tables useful outside gaming, and how does Dice Roller make them actionable?

Random tables act as a structured creative reboot: they force selection from a curated set rather than blankly brainstorming. In the performance-testing example, markdown tables list common problems and principles. Dice Roller selects a row from the table (using a caret/identifier in the dice syntax) so the user can quickly roll prompts for what to test next. Preview mode lets the user roll through multiple prompts, and hovering reveals the table’s description content.

How can Dice Roller return only what you need from a table or from tagged notes?

Table output can be filtered by specifying which columns to show using a pipe selector—e.g., showing only “problem” or only “description” instead of both. For tags, Dice Roller can return links to notes rather than embedding full content by using a hashtag tag selector with a “link” option (e.g., hashtag TVZ | link). This supports a practical workflow like pulling one item from a processing queue without loading dozens of notes.

What does Dice Roller mean by “random blocks,” and how can it target specific sections?

Dice Roller can return random blocks from within notes, including code blocks, headings, images, and lists. For lists, using listitem returns a single bullet point rather than the entire list. For headings, specifying a level like heading-2 restricts results to that section level, so re-rolls stay within a chosen top-level topic. These selections work across notes as long as the syntax points to the relevant page.

Review Questions

What are two different ways Dice Roller can customize output beyond simply rolling a number (e.g., dice mod, column selection, link vs embed)?
Give one example of how random tables can support a real work workflow, and describe how the roll result is used.
How do tag-based rolls differ from table-based rolls in what they return and why that matters for daily use?

Key Points

1
Dice Roller turns Obsidian notes into interactive randomness tools using simple dice formulas like 1d20 with live preview and re-roll support.
2
The plugin supports more than basic rolls: modifiers, percentile dice, FUDGE/Fate dice, advantage/disadvantage mechanics, exploding dice, and success-threshold counting.
3
Randomness can be applied to dataview fields by combining parameters with dice formulas (e.g., multiplying priority and urgency, optionally adding constants or extra dice).
4
Curated markdown tables can be “rolled” to generate prompts for what to test next, with hoverable descriptions and column-level output control.
5
Tag-based rolls can function like a processing inbox by returning links to notes with a specific tag (such as TVZ) rather than embedding entire notes.
6
Dice Roller can return random blocks from notes—like a single list item or a specific heading level—so re-rolls stay within the right context.
7
Using “dice mod” changes display behavior by returning only the computed result instead of showing the underlying formula.

Highlights

Typing 1d20 in Dice Roller produces a virtual d20 roll with hover details and clickable re-rolls, making randomness immediate inside Obsidian.

Dice Roller can roll on dataview fields and combine them with formulas like priority * urgency, including optional added randomness via extra dice.

Random tables become practical prompts for performance testing: each roll selects a curated problem or principle, and hovering reveals the associated description.

Tag rolls can return only links to notes tagged for processing (e.g., TVZ), reducing overwhelm compared with embedding full note contents.

Block-level targeting lets Dice Roller pick a single list item or restrict results to heading-2 or heading-3 sections, keeping outputs focused.

Topics

Obsidian Plugin
Dice Syntax
Random Tables
Dataview Fields
Tag-Based Retrieval

Mentioned

Jeremy Valentine
Nicole van der Hoeven
d20
d10
d8
d percentage