Canna71/obsidian-sets: The Obsidian plugin that turns filters into editable databases

A local-first data layer for Markdown notes, where query results are not just readable. They can write properties back into the file itself.

8 to 10 min read • View on GitHub • More from Canna71

A loose stack of Markdown note cards transforms into a structured filing system with columns, boards, and linked cards. The scene explains how a plain Obsidian vault can start behaving like a database without leaving local files behind.
Sets takes the chaos of a note vault and gives it a shape, but the files stay files.
Key Takeaways

The strange and useful thing about obsidian-sets is that it does not stop at showing you a filtered list of notes. It lets that filtered view act like a constrained form, so creating or editing inside the view can push properties back into frontmatter. That changes the mental model from "query the vault" to "edit through the query."

That shift is the whole article. Plenty of Obsidian plugins can read YAML and render neat dashboards. Sets is more interesting because it tries to make the view itself participate in data entry, which is why it feels closer to a local-first database UI than a reporting layer.

The filter is the form

The best way to understand Sets is to start with the behavior that feels slightly impossible. You filter for a subset of notes, then create a new note inside that filtered result, and the plugin treats the filter as part of the note’s shape. The result is not just a note appearing in the right place. It is a note arriving with the right properties already enforced.

The important move is not filtering. It is letting the filter define what new data must look like.

At the user level, that means a board or grid can act like a data entry surface. At the architecture level, it means the plugin needs a mediator between files and views, because the UI cannot be poking raw notes directly and still stay coherent.

How a vault becomes a database

The core of the system lives in VaultDB. It watches Obsidian’s metadata cache, keeps an internal index, and returns wrapped ObjectData records that combine the file object with its frontmatter. That matters because views are not querying notes in place. They are asking for structured records from a layer that already knows how to reconcile file data and metadata.

// Simplified shape of the data flow
const record = new ObjectData(file, frontmatter)
const results = vaultDB.query(clauses)
view.render(results)

// metadata changes are debounced before reindexing
metadataCache.onChange(() => debounce(reindex, 100))

That debounce is a small detail with a large effect. Obsidian vaults can change fast, and a plugin that rebuilds its world on every edit would feel brittle. The 100ms buffer is the kind of engineering choice that disappears when it works and dominates the experience when it does not.

The abstraction is also broad enough to unify intrinsic file facts, like name or path, with user-defined properties. In practice, that lets a note’s file system identity and its semantic data live in the same query surface.

The query engine does more than filter

Sets uses its own clause system, and that is important because the engine is not just a boolean gate. It sorts clauses by selectiveness before evaluation, which means high-signal operators can run earlier and shrink the search space before less selective checks kick in. That is a practical optimization, but it also hints at a design goal: efficient enough to feel interactive, opinionated enough to model data rules.

const ordered = clauses.sort(
  (a, b) => getOperatorById(b.op).selectiveness - getOperatorById(a.op).selectiveness
)

for (const clause of ordered) {
  if (!evaluate(clause, objectData)) return false
}
return true

The other important piece is dynamic values. A query can refer to context such as "this file," which makes the system useful for relationships without demanding full SQL. That is where Sets starts to look relational, even if it never crosses all the way into joins and aggregations.

This is also why the plugin can be expressive without becoming code-first. Dataview gives you a powerful query language. Sets tries to give you a query language you can operate with your hands.

Why SolidJS matters here

A close-up engraving of a hand moving one tile in a densely packed grid while the surrounding tiles remain still. The image explains why fine-grained reactivity matters when editing a large note collection inside a responsive interface.
SolidJS helps Sets update one cell without repainting the whole board.

SolidJS is a smart fit because this plugin lives and dies on local responsiveness. When a single property changes, you want the smallest possible part of the interface to update. Fine-grained reactivity is useful in any app. In an Obsidian plugin that may be rendering large boards or grids over thousands of notes, it is the difference between "snappy" and "always a little tired."

That choice also reinforces the project’s broader philosophy. Sets is not trying to import a heavy app shell into Obsidian. It is trying to make a document interface behave like a data application while staying close to the host’s native model.

The write-back trick that makes Sets feel database-like

This is the sharpest technical idea in the repo. Operators are not just validators. They can also enforce values. When a new item is created inside a filtered view, the operator’s enforce logic can inject the missing property into frontmatter so the note satisfies the view’s constraint from the start.

"hasall": {
  enforce: (current: unknown, val: unknown) => {
    const ret = (!current || !Array.isArray(current)) ? [] : current.slice();
    // ... logic to push missing items
    return ret;
  }
}

That pattern is quietly powerful. It is the closest thing Sets has to schema. The filter does not merely describe a set of matching notes. It can also define what must be written for a new note to belong there.

Once you see that loop, the rest of the architecture clicks into place. Query clauses select, operators normalize, write-back updates metadata, and the index refreshes the rendered view. The plugin is less a dashboard and more a controlled feedback system.

This plugins is inspired by Notion and AnyType and implements a way to strucure data using obsidian notes, specifically the recently released properies.

Gabriele Cannata, Project Author · Canna71/obsidian-sets README

Sets vs Dataview, Projects, DB Folder, and Make.md

PluginMain strengthPrimary interaction modelWhat Sets does differently
DataviewBest-in-class queryingRead and renderSets is GUI-first and editable, not mainly read-only.
ProjectsOpinionated workflow trackingProject-centric boards and viewsSets is broader and works for any structured note collection.
DB FolderEditable database feelFolder-backed data tablesSets is more self-contained and does not lean on the same external pattern.
Make.mdAll-in-one Obsidian overhaulBroad workspace and database layerSets is narrower, lighter, and more focused on one job.
SetsEditable database layer for notesFilter, create, and write backIts defining move is that the view can enforce data as it writes.

The strategic position is clear: Dataview still wins on raw querying power, but Sets owns the interaction story. It is the most focused attempt here to make structured note editing feel native, visual, and local-first without turning Obsidian into a different product.

What Sets is really building

Sets is not trying to replace the file system. It is trying to impose a durable data model on top of plain Markdown while keeping the vault legible outside the plugin. That is a compelling constraint, because it preserves portability and avoids locking the user into a separate database file.

The tradeoff is maturity. The code shows an intentional architecture, but the project still lacks some of the machinery you would expect from a full relational system, especially joins and aggregations. It is also a single-maintainer project, which gives it coherence and a real bus-factor risk at the same time.

That does not make it less interesting. It makes it honest. Sets is a sharp answer to a very specific Obsidian problem: how do you get database behavior without giving up Markdown, local files, or control over your own vault?