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.
- Sets matters because a filtered view can become a writable surface, not just a readout of note metadata.
- VaultDB, clause ordering, and operator enforcement work together to make Markdown feel locally relational without introducing a separate database file.
- SolidJS is not a cosmetic choice here, because fine-grained reactivity keeps the UI responsive while the vault changes underneath it.
- Sets is best understood as a focused editable layer for structured notes, with clear limits compared with Dataview, Projects, DB Folder, and Make.md.
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.
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
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.
Sets vs Dataview, Projects, DB Folder, and Make.md
| Plugin | Main strength | Primary interaction model | What Sets does differently |
|---|---|---|---|
| Dataview | Best-in-class querying | Read and render | Sets is GUI-first and editable, not mainly read-only. |
| Projects | Opinionated workflow tracking | Project-centric boards and views | Sets is broader and works for any structured note collection. |
| DB Folder | Editable database feel | Folder-backed data tables | Sets is more self-contained and does not lean on the same external pattern. |
| Make.md | All-in-one Obsidian overhaul | Broad workspace and database layer | Sets is narrower, lighter, and more focused on one job. |
| Sets | Editable database layer for notes | Filter, create, and write back | Its 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?





