Get AI summaries of any video or article — Sign up free
Obsidian Bases: Obsidian's Biggest Upgrade (Complete Guide) thumbnail

Obsidian Bases: Obsidian's Biggest Upgrade (Complete Guide)

6 min read

Based on Linking Your Thinking with Nick Milo's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Obsidian Bases’ standout value is dynamic links: embedded Bases views auto-update based on the note currently selected, turning backlinks into context-rich navigation.

Briefing

Obsidian Bases’ biggest upgrade isn’t just faster organization—it’s the way it turns note links into live, contextual “dynamic links” that update as soon as you click into a note. That shift changes how people navigate an “idea verse”: instead of browsing a static database or scrolling a backlink list with no context, Bases can surface the right subset of related notes (movies, quotes, people, projects, calendar entries, and more) in a sidebar, sorted and filtered to match the note you’re currently viewing.

Speed is the first practical win. Creating a new base via Command-P (Mac) or Control-P (Windows) is described as effectively instantaneous, with built-in optimizations for scrolling large tables. The workflow is tested against vaults with tens of thousands of files, and the experience remains smooth while moving through large result sets.

The second major feature is that a single base can hold multiple views—table, cards, and more—each showing the same underlying dataset through different lenses. In the “sources” example, one base contains pre-built views for books, shows, and other categories. Clicking between views immediately changes layout and filtering without rebuilding anything.

The third feature is live editing with autocomplete, letting users rapidly update properties (like ratings) and see those changes propagate into the base’s sorted results right away.

Under the hood, Bases rely on note properties. Properties live inside individual notes (for example, a “book” note can store metadata such as year, rating, and other fields). Bases then use those properties to create columns, sort order, and filters. The transcript emphasizes that properties are the control panel: once they’re present, Bases can filter and present notes that match specific parameters.

Views are where the system becomes usable. A “main view” can apply a global filter (such as “folder contains sources”), and then each duplicated view adds its own narrower filter (such as “folder contains …/books”). This structure keeps shared constraints consistent while letting each view focus on a different slice of the vault.

The most transformative capability is embedding views via Obsidian syntax and “dynamic links.” When a note includes an embedded reference to a specific Bases view, the embedded results auto-update based on the note you’re currently in. The transcript demonstrates this with directors like Peter Jackson, Hayao Miyazaki, and James Cameron: clicking between director notes updates the sidebar to show only the movies in the database that match that director, sorted by personal rating.

The walkthrough then scales up into a full personal system (“Ideaverse Pro 2.5” and related bases). Bases are organized around an “ACE folder framework” (Atlas, Calendar, Efforts, X/Extra, plus an Add folder). High-level bases (like “Atlas,” “Dots,” “Maps,” “Sources,” and “Projects”) are intentionally broad, while views inside them zoom in by note type—people, questions, quotes, statements, and “dots” (timeless knowledge units). The result is a navigational map where clicking a note reveals connected context across time, projects, and collections.

Practical automation also appears: Claude Code is used to populate missing book cover images by finding notes with an “image” YAML property and then searching online (via a Google Books API approach) for covers, ultimately updating dozens of book notes.

Finally, the transcript argues that Bases make links more meaningful rather than replacing writing. Dynamic links and contextual sidebars are framed as “echolocation” for memory—reinforcing relationships over time—while guidance urges users to start small (10–20 notes) and expand gradually, rather than trying to retrofit properties across thousands of notes at once.

Cornell Notes

Obsidian Bases turns note collections into fast, queryable databases built on note properties. A base can contain multiple views (table, cards, etc.) that share global filters while applying view-specific filters, letting users zoom in on different slices of the same dataset. The key leap is dynamic links: embedded Bases views auto-update based on the note currently selected, so a sidebar can show context-rich results (e.g., all movies directed by the person you clicked) instead of a generic backlink list. This makes navigation feel like exploring a “three-dimensional” idea map, reinforcing memory and strengthening connections as work continues.

What makes Bases feel “instant,” and why does that matter for large vaults?

Bases creation is described as effectively instantaneous via Command-P (Mac) or Control-P (Windows). The transcript attributes the responsiveness to optimizations for scrolling large tables, including handling vaults with tens of thousands of files without issue. That speed matters because the workflow depends on rapid switching between views and frequent property edits—if scrolling and filtering lagged, the system would discourage exploration.

How do note properties control what appears in a base?

Properties are stored inside individual notes (e.g., a “book” note includes metadata like year and rating). Bases then expose those properties as columns and use them for sorting and filtering. The transcript also notes that Bases can use global properties that all notes have (like file base name), and users can add or remove properties from the base’s property list to shape the dataset.

What’s the practical difference between a base’s “main view” filter and a view-specific filter?

The transcript describes a best-practice pattern: set a main view with a global filter (example: “folder contains sources”), then duplicate that view and add narrower filters per view (example: “folder contains …/books” to get 126 results). This keeps shared constraints consistent across views while letting each view focus on a different subset without losing the overall structure.

How do dynamic links change the experience of backlinks?

Instead of a static backlink list with little context, dynamic links embed Bases views that update automatically for the currently selected note. The transcript demonstrates this with director notes: clicking Peter Jackson updates the sidebar to show only the movies in the database where he’s the director, sorted by personal rating. Clicking Hayao Miyazaki or James Cameron triggers the same embedded view to refresh with their matching results.

Why does the transcript recommend starting with broader bases rather than the narrowest possible one?

The system is built so each view becomes a narrower subset of a broader base. Example: start with the entire “atlas” folder (3,288 results), then create views for distinct categories like dots, maps, and sources. This reduces the need to rebuild structure and makes it easier to add or adjust views as the vault evolves.

How was AI used to enrich the vault beyond text properties?

Claude Code was used to populate missing book cover images. The workflow targeted notes in a directory that already had an “image” YAML property, then identified books lacking images (the transcript cites 79 needing covers). It attempted online cover lookup (described as using a Google Books API approach), initially updating a few books, then switching to an automated Python-script approach to complete the batch and update most missing images.

Review Questions

  1. When you create a new view in Bases, how do you ensure it inherits the main view’s global filter while adding its own narrower filter?
  2. What role do note properties play in enabling sorting and filtering inside a base? Give one concrete example from the transcript.
  3. How do dynamic links differ from standard backlinks in terms of context and what appears in the sidebar?

Key Points

  1. 1

    Obsidian Bases’ standout value is dynamic links: embedded Bases views auto-update based on the note currently selected, turning backlinks into context-rich navigation.

  2. 2

    Bases are built on note properties; without consistent metadata inside notes, sorting and filtering inside Bases can’t work as powerfully.

  3. 3

    A base can host multiple views (table/cards), letting one dataset be explored through different layouts and filters without rebuilding the structure.

  4. 4

    Use a “main view” for global constraints (like a root folder) and duplicate views to add narrower filters for each category (like books vs. shows).

  5. 5

    Start with broader bases (e.g., an entire folder) and let views zoom in; this keeps the system flexible as needs change.

  6. 6

    AI can automate enrichment tasks like adding missing book cover images by filling YAML properties and updating many notes in batches.

  7. 7

    Adopt a gradual rollout: begin with a small set of notes (10–20) and expand, rather than retrofitting properties across thousands of files at once.

Highlights

Dynamic links embed Bases views so the sidebar updates instantly when clicking a note—e.g., director notes refresh the “shows director” results to show only that director’s movies.
Bases rely on properties inside notes; once metadata exists, views can sort and filter instantly, including live edits like rating changes.
The recommended view architecture uses a global filter in a main view and narrower filters in duplicated views to keep structure consistent.
Claude Code was used to find missing book cover images and populate YAML “image” properties, turning a large manual enrichment task into an automated batch workflow.
The transcript frames Bases as “echolocation” for memory: contextual sidebars reinforce relationships over time instead of leaving users with contextless backlink lists.

Topics

Mentioned