Get AI summaries of any video or article — Sign up free
Obsidian - Meta Bind - Input Fields and Calculators thumbnail

Obsidian - Meta Bind - Input Fields and Calculators

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

Meta Bind combines saved “import fields” with live “views” to create interactive RPG calculators inside Obsidian notes.

Briefing

Meta Bind turns Obsidian notes into interactive RPG calculators by combining saved input fields with live-updating “views” that can run math and pull data from other notes. The payoff is practical: dropdowns and selectors keep their chosen values instead of resetting when a note is reopened, and calculations refresh in near real time—fixing the lag and manual refresh problem many users associate with earlier DataView-style approaches.

The plugin’s core workflow is built around two components. “Import fields” create user inputs—text boxes, dropdowns, sliders, date/time pickers, image selectors, and more—and store the selected results into note properties. “Views” then display those stored properties and can also perform formulas, including referencing properties from other notes. That combination is what powers everything from simple pickers to full travel and jump calculators.

A standout example is a travel calculator refreshed by dropdown-driven party settings. Changing an animal type (e.g., donkey walking vs. griffin flying) updates base speed, which then cascades into travel time estimates between towns. The same calculator also reacts to party configuration inputs like travel duration per day, exhaustion level, travel mode, route safety, familiarity, party size, wealth level, and whether meals are included—driving outputs such as days to travel and travel costs (gold and copper) based on coaching, messenger, and ship-per-day assumptions. The results are stored in properties, so other notes can reuse the same configuration data.

Beyond calculators, Meta Bind addresses a long-standing annoyance: dropdowns that don’t persist. Earlier workarounds using HTML in Obsidian let users select options visually, but the chosen value wouldn’t reliably save, so it reverted on reopening. Meta Bind’s saved-value dropdowns keep the underlying property consistent, enabling stable templates and repeatable character- or campaign-driven calculations.

There’s also a known edge case with inline select controls: if multiple options share the same underlying value, reopening the note may default to the first matching option (the transcript’s example shows an animal changing back to “donkey” when another option shares the same speed value). The creator’s workaround adds tiny fractional offsets (e.g., 0.01, 0.02, 0.03) to force unique stored values, then rounds during calculations so the displayed results remain clean.

Implementation details matter because Meta Bind is “advanced” and actively changing. The transcript emphasizes reading the plugin documentation and GitHub example vault, which includes ready-to-copy snippets. It also distinguishes inline vs block input field styles (with some features available only in block mode) and shows how views can be written inline using property references and math operators.

Finally, the transcript positions Meta Bind as a stepping stone toward richer RPG tooling in Obsidian—currency converters, D&D 5e travel calculators, and even a Pathfinder 2e jump calculator—while encouraging users to copy examples, modify them, and share improvements in the community Discord.

Cornell Notes

Meta Bind adds interactive “import fields” and live “views” to Obsidian so RPG notes can behave like calculators. Inputs (dropdowns, sliders, date/time pickers, etc.) save their selected values into note properties, and views can display those properties and run math formulas. Views can also reference properties from other notes, enabling multi-note systems like a travel calculator driven by a separate “party configuration” note. A key benefit over older DataView-style methods is near real-time updating without needing to leave and return to refresh. The transcript also flags an inline-select pitfall: if multiple options share the same stored value, reopening can revert to the first match; a workaround uses tiny fractional offsets plus rounding to keep results accurate.

How do import fields and views work together in Meta Bind?

Import fields create user inputs and store the selected results into Obsidian note properties (e.g., a date field saves into a property like “date one”). Views then render those properties in the note and can also compute formulas. The transcript emphasizes that these are separate components: import fields handle input/state, while views handle display and calculation.

What makes Meta Bind’s dropdowns more reliable than earlier HTML-based approaches?

Earlier HTML dropdown workarounds let users pick an option visually, but the chosen value didn’t persist—leaving and reopening the note reset the selection. Meta Bind dropdowns save the underlying value into properties, so the selected option remains after reopening. The travel calculator example demonstrates this persistence when changing travel mode affects downstream outputs.

Why does the transcript mention a problem with inline select controls, and what’s the workaround?

If multiple dropdown options share the same underlying stored value (example: different animals with the same speed value), reopening can default to the first option that matches that value. The workaround adds tiny fractional offsets to make each stored value unique (e.g., 0.01, 0.02, 0.03), then uses rounding so the displayed/used results stay correct.

How can views perform calculations and pull data from other notes?

Views support math formulas using properties. They can reference properties from other notes using a reference pattern that brings in values like “base speed” from a separate party configuration note. The transcript’s travel system relies on this cross-note property referencing to keep calculations consistent across multiple notes.

What’s the practical difference between Meta Bind and the older DataView-style calculator approach?

The older approach required leaving a note and coming back for calculations to refresh. Meta Bind updates in near real time, so changing inputs (like walking vs flying) immediately updates dependent outputs such as travel days and costs without manual refresh.

What does the transcript recommend for learning Meta Bind effectively?

Use the plugin documentation and GitHub example vault, which includes copyable snippets and an example vault full of working patterns. Then copy calculators from the creator’s site (e.g., currency converter, travel calculator, Pathfinder 2e jump calculator), modify them for personal needs, and share questions or solutions in the community Discord.

Review Questions

  1. What two Meta Bind components are responsible for saving user input and for rendering/calculating outputs, and how do they interact?
  2. Describe the inline-select persistence issue related to duplicate underlying values and explain the fractional-offset workaround.
  3. Give one example of how a view can reference properties from another note and how that enables a multi-note RPG calculator.

Key Points

  1. 1

    Meta Bind combines saved “import fields” with live “views” to create interactive RPG calculators inside Obsidian notes.

  2. 2

    Dropdowns and selectors persist because chosen values are stored in note properties, avoiding the reset behavior of earlier HTML-based workarounds.

  3. 3

    Views can run math formulas and can reference properties from other notes, enabling systems like travel calculators driven by a separate party configuration note.

  4. 4

    Near real-time updating removes the refresh delay common in earlier DataView-style calculation workflows.

  5. 5

    Inline select controls can misbehave when multiple options share the same underlying stored value; tiny fractional offsets plus rounding can force unique stored values.

  6. 6

    The plugin’s documentation and GitHub example vault are essential because Meta Bind is advanced and actively changing.

  7. 7

    Copying and modifying ready-made calculators (currency, travel, jump) is the fastest way to learn the syntax and patterns.

Highlights

Meta Bind’s biggest win is persistence: dropdown selections stay saved in properties instead of resetting when a note is reopened.
Live calculations become possible because views update near real time and can chain off stored properties.
Cross-note referencing lets one “party configuration” note drive multiple calculators elsewhere.
A known inline-select edge case appears when different options share the same stored value; fractional offsets fix it without changing displayed results.
The learning path emphasized in the transcript is documentation + GitHub example vault + copyable calculators to experiment with.

Topics

  • Meta Bind
  • Obsidian Calculators
  • RPG Travel Calculator
  • Input Fields
  • Views and Formulas

Mentioned