Get AI summaries of any video or article — Sign up free
Obsidian Insider Sneak Peak - Bases - Maps View thumbnail

Obsidian Insider Sneak Peak - Bases - Maps View

Josh Plunkett·
6 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

The Bases API is a platform shift that lets community developers build new Bases views like maps, not just tables and lists.

Briefing

Obsidian Bases is getting a major upgrade: a new Bases API is opening the door for community-built plugins, and the first standout showcase is a “Maps View” plugin that can pin notes onto an interactive map. The practical impact is straightforward—Bases can already filter vault content into tables and lists, but the API turns that filtered data into a platform where developers can add entirely new visualization modes. That matters because it shifts Bases from a feature set into an ecosystem, with early momentum already visible in community releases like a calendar plugin and now map-based navigation.

The sneak peek begins with Obsidian Insider access, including a “catalyst license” that grants early builds. From there, the focus lands on what Bases does at its core: it behaves like a Data View for notes—querying a vault for entries that match requirements and then rendering the results. New UI capabilities are already in play, including grouping results, adding summaries, and introducing a list view alongside the existing table-style presentation.

The real turning point is the Bases API. Instead of waiting for core development cycles to add new views, the API lets plugin developers create their own Bases renderers. The immediate consequence is a wave of community experimentation: a calendar plugin has already appeared, and a Maps plugin is now being used to demonstrate how far the API can go.

The Maps View shown here supports pinning: each map marker is tied to a note, and clicking a pin jumps to the linked note. The map itself is interactive—users can zoom in and out, drag the map around, and select markers. The plugin is installable from Obsidian’s community plugins directory, but it’s framed as not fully released for everyone; Insider users can find it earlier.

A key technical detail is that the showcased setup is not the “official out-of-the-box” maps plugin. The demonstration uses a locally modified build that adds support for local map images rather than relying solely on an online tile server. Tile servers provide the multi-image zoom experience (hundreds or thousands of tiles that change as you zoom), while local images require different handling. The transcript describes how community discussion and GitHub issue activity pushed for additional functionality, and how a pull request was extracted and merged into a custom build to enable local backgrounds.

Setup is driven by Bases configuration plus note properties. The map view includes settings like embed height, default center coordinates, default zoom, and min/max zoom limits. Markers come from note frontmatter-style properties: coordinates (X/Y), an icon, and an icon color (using hex/RGB-style values). The workflow is intentionally simple: create a pin note, right-click the map to copy coordinates, paste them into the note, then choose an icon from Obsidian’s icon library.

For multiple maps, the plugin relies on Bases filtering. Each view can show only the pins that match a filter such as folder location or a property like “map name.” The transcript also flags a current limitation: if two notes share the exact same name, only one pin appears, prompting a reported bug.

Finally, the discussion looks ahead. With the API in place, timelines, calendar variants, and other visualization plugins are framed as plausible next steps. There’s also interest in workflow improvements—like right-clicking to create a pin note automatically—and in making map measurement easier than Leaflet-style pixel math. Overall, the core message is that Bases is becoming a plugin-driven canvas, and map views are a concrete early example of what that future could look like for TTRPG-style note systems and beyond.

Cornell Notes

Obsidian Bases is evolving from a query-and-render feature into a plugin platform thanks to a new Bases API. That API enables developers to build new visualization views, and the early highlight is a Maps View that places note-linked pins onto an interactive map with zoom and click-through navigation. The demonstrated setup uses note properties for marker placement (coordinates plus icon and icon color) and Bases settings for map defaults like center point and zoom limits. Multiple maps are handled through Bases filters (e.g., folder-based or property-based), letting one base contain several map views. The approach is powerful but currently has constraints, including a bug where duplicate note names can cause pins to collapse into one.

What does the Bases API change for Obsidian users and developers?

It turns Bases from a fixed set of built-in views into an extensible system. With the API, community developers can create their own Bases views and renderers—so features like maps, calendars, and other visualizations can arrive without waiting for core releases. The transcript frames this as an “enabler” for plugins specifically for Bases, and notes that a calendar plugin has already appeared after the API release.

How does the Maps View connect map pins to notes?

Each pin is generated from a note’s properties. Marker configuration relies on coordinates (X/Y), an icon, and an icon color. In practice, users create a pin note, right-click the map to copy coordinates, paste those coordinates into the note’s properties, then set the icon (from Obsidian’s built-in icon library) and a hex color value (e.g., red or blue). Pins are then rendered in the Bases map view, and clicking a pin opens the linked note.

Why does the transcript emphasize that the shown maps setup is not the official plugin build?

The demonstration uses a locally modified version that supports local background images. The original maps plugin behavior is described as relying on a tile server—an online set of map tiles that changes as you zoom. The custom build extracts changes from a GitHub pull request to add local image support, so the setup is presented as “in development” and not standard release functionality for typical users.

How are multiple maps managed inside a single Bases base?

Multiple maps are handled by creating multiple Bases views and filtering which notes feed each view. The transcript gives examples like filtering by folder (e.g., a folder dedicated to “Red Larch” pins) or filtering by a property such as “map name.” Without the filter, the view would show pins for all notes visible to that base; with the filter, each map view shows only the intended subset.

What limitations or conflicts does the transcript call out?

Two main issues appear. First, if two notes have the exact same name, only one pin shows up, leading to a reported GitHub bug. Second, there’s a plugin interaction: if a property name starts with “icon,” the Pixel Banners plugin’s CSS may hide those properties, so the transcript suggests avoiding property names that begin with “icon” when Pixel Banners is installed.

What workflow improvements are suggested for future map usability?

The transcript argues for reducing manual steps. Ideas include adding a UI button to browse/select a map image instead of copying relative paths, and improving measurement support so users don’t need to calculate bounds/pixels manually (as required by Leaflet-style setups). It also mentions a desired right-click workflow to create a new pin note automatically, with developers indicating it would require a future Obsidian update.

Review Questions

  1. How does the Maps View determine where to place pins, and which note properties are required?
  2. What mechanisms does Bases use to show different sets of pins for different map views?
  3. Why might duplicate note names cause pins to disappear, and what workaround does the transcript imply?

Key Points

  1. 1

    The Bases API is a platform shift that lets community developers build new Bases views like maps, not just tables and lists.

  2. 2

    Bases already supports querying vault notes into grouped results, summaries, and multiple display styles, but the API expands what “display” can mean.

  3. 3

    The showcased Maps View pins notes onto an interactive map using note properties for coordinates, icon, and icon color.

  4. 4

    The demonstration relies on a locally modified maps build that adds local background image support beyond the tile-server approach.

  5. 5

    Multiple maps in one base are created by adding multiple views and using Bases filters (folder or properties like “map name”) to limit which pins appear.

  6. 6

    Current constraints include a bug where notes with identical names can result in only one pin being shown.

  7. 7

    Future improvements discussed include easier map selection, better measurement UX, and right-click pin creation that can generate new notes automatically after an Obsidian update.

Highlights

The Bases API turns Bases into an ecosystem: developers can create entirely new visualization views, with maps and calendars already emerging.
Pins are note-driven—right-click coordinate copying plus note properties (coordinates, icon, icon color) automatically populate map markers.
Local map backgrounds are possible via a GitHub pull request–based modification, moving beyond tile-server-only zoom behavior.
Multiple map views are achieved through filtering, so one base can host separate maps like “Red Larch” without showing every pin in the vault.
A practical bug is flagged: duplicate note names can cause pins to collapse, so unique naming is currently required.

Topics

Mentioned