Get AI summaries of any video or article — Sign up free
Obsidian - Bases Insider Release (2025) thumbnail

Obsidian - Bases Insider Release (2025)

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

Bases introduces dynamic, property-driven tables inside notes with multiple named views that can be switched via UI controls.

Briefing

Obsidian’s Bases insider release brings “dynamic tables” directly into notes—letting users build multiple filtered, clickable views without writing DataView-style queries. The core shift is that a single Bases block can host several named views (with their own filters, sorting, and column choices), and the results update instantly as underlying note properties change. For TTRPG and other knowledge-base workflows, that means dashboards like “recently modified,” “party members,” or “hubs in this region” can become interactive menus rather than static query outputs.

The release is positioned as a blend of DataView and database-table concepts. Instead of hardcoding one query per table, Bases lets users define a table layout inside a “base” file type (or inline base blocks) and then configure views within it. Users can switch between views using buttons or dropdown-style controls, with filters scoped either to a single view or to all views in a group. In the demo, a “recently modified” view shows the last 10 items, while other views can target specific folders and property conditions—such as limiting results to notes inside “two-world hubs” or “two-world places.”

A key usability detail is how Bases handles properties. Users can add columns by selecting existing note properties (like “folder,” “created time,” “modified time,” or custom properties such as “Obsidian UI mode”) and can also add formula-based properties. The interface also supports searching and dragging properties into the table, avoiding the friction of query syntax. Previewing page content requires holding Control for now, tied to Obsidian’s core “page preview” behavior, indicating the feature is still early and not fully integrated into defaults.

Creating Bases is straightforward: right-click a folder to create a new base file, or insert an inline base block by typing “base” in a note. The demo shows that Bases can be dragged into Canvas and even embedded into Excalidraw, with partial editability—useful for building visual dashboards and planning boards. Performance is repeatedly described as “snappy,” with updates feeling faster than traditional DataView tables on large notes.

The roadmap signals where this could go next: a Bases API for plugin developers, additional view types beyond tables (lists, cards), aggregation functions (sum/average), and native Obsidian Publish support. The presenter also flags likely gaps—especially around image handling (cards and image properties), and the current limitation that option pickers may only show values already used in the vault’s properties. There’s also interest in more dynamic option selection, such as choosing from a folder-derived set of items.

Overall, Bases is presented as a practical replacement for DataView tables and database-folder-style workflows, particularly for users who want interactive, property-driven dashboards without learning query-heavy approaches. It’s currently available through Obsidian Insider, with the expectation that plugin and theme ecosystems will need time to adapt.

Cornell Notes

Bases is an Obsidian Insider feature that turns “dynamic tables” into first-class note components. A single Bases block can contain multiple named views, each with its own filters, sorting, and columns, so users can switch dashboards via buttons/dropdowns instead of writing separate DataView queries. Columns can be built from existing note properties, and formula properties enable calculated fields. Bases can be created as a separate “base” file type or embedded inline in a note, and it updates reactively when underlying properties change. The roadmap points to an API, new view types like cards, aggregation functions, and native Obsidian Publish support—suggesting it may replace many DataView table use cases while leaving deeper DataView.js-style automation to other tools.

How does Bases change the way users build dynamic lists compared with DataView?

DataView typically relies on one query per table. Bases instead lets a single base block host multiple views (e.g., “recently modified,” “party members,” “hubs,” “places”), each with its own filter rules and layout settings. Users then switch views using UI controls, while the results update automatically from note properties. In the demo, “recently modified” is configured to show the last 10 items, while other views filter by folder paths like “two-world hubs” or “two-world places.”

What does “views” mean inside a Bases block, and how are filters scoped?

A “view” is a named section inside the Bases configuration (often grouped under a table). Each view can have its own filters and presentation settings. The demo distinguishes between an “all views” filter (applies across the whole grouping) and a “this view” filter (applies only to the selected view). That scoping lets users reuse the same base layout while tailoring each dashboard tab to different subsets of notes.

How are table columns populated in Bases?

Columns come from note properties. Users can add standard fields like folder, created time, and modified time, plus custom properties such as “Obsidian UI mode.” The interface supports searching for property names and dragging them into the table. The demo also notes that property option pickers may only show values already used in the vault, which can hide unused options unless the user types them.

What’s the difference between creating Bases as a separate file versus embedding it inline?

Bases can be created by right-clicking a folder and choosing “new base,” which generates a base file type. Alternatively, users can insert an inline base block by typing “base” in a note (similar to starting a DataView query). The demo shows inline bases can be edited via a “source” mode, and changes write back into the note block in real time. Both approaches support configuration, filtering, and view switching.

How does Bases handle preview and embedding in other Obsidian surfaces?

Previewing page content currently requires holding Control, tied to Obsidian’s core “page preview” setting (hover behavior isn’t fully defaulted yet). For embedding, the demo shows Bases blocks can be dragged into Canvas and appear functional inside Excalidraw, though editing may be limited—useful for integrating dashboards into visual planning workflows.

What future capabilities are hinted by the Bases roadmap?

The roadmap mentions a Bases API for plugin developers to add custom functions and new view types. Expected view types include lists and cards. Other items include aggregation functions like sum/average and native Obsidian Publish support, which could eliminate hacks currently used to make DataView work on Publish.

Review Questions

  1. What mechanisms in Bases let users switch between multiple filtered dashboards without writing multiple separate queries?
  2. How does Bases populate selectable filter options and what limitation does the demo suggest about unused property values?
  3. Which roadmap items would most directly affect how Bases is used for visual dashboards (e.g., cards, images, Publish support)?

Key Points

  1. 1

    Bases introduces dynamic, property-driven tables inside notes with multiple named views that can be switched via UI controls.

  2. 2

    Each view can have its own filters, sorting, and columns, with “all views” vs “this view” scoping for filter rules.

  3. 3

    Table columns are built by selecting existing note properties (including custom properties), reducing reliance on query syntax.

  4. 4

    Bases can be created as a separate base file type or embedded inline using a “base” block, and edits can be made in real time via source mode.

  5. 5

    Bases updates are described as highly responsive compared with traditional DataView table refresh behavior on large notes.

  6. 6

    Preview behavior currently requires holding Control, indicating the feature is still early and not fully integrated into default hover preview.

  7. 7

    The roadmap points to a plugin API, new view types (including cards), aggregation functions, and native Obsidian Publish support.

Highlights

Bases lets one block contain multiple views—turning what used to be separate DataView queries into a clickable dashboard menu.
Filters can apply to all views in a group or only the currently selected view, enabling reusable base layouts.
Inline bases are created by typing “base” in a note, and changes write back into the block’s source immediately.
Bases can be dragged into Canvas and embedded into Excalidraw, making it usable in visual workflows.
Native Obsidian Publish support and card-style view types are flagged as major next steps.

Topics

  • Obsidian Insider
  • Bases Views
  • Dynamic Tables
  • DataView Alternatives
  • Canvas Embeds

Mentioned