Capacities.io gets something
The current state of Capacities.io hints that its developers understand something other apps are struggling with — building foundation features and letting the user make the rest, instead of getting lost in the weeds of special features.
This is a bold statement to start with, but ever since I stumbled across the first gold nugget by accident less than a week ago, the observations have been cascading.
I think Capacities.io has a bright future ahead of them because, from what I have seen so far, they understand something that other apps struggle with — even (or maybe especially) Notion. Capacities designers excel at software engineering in both the domains of user experience and functional decomposition. And this lets them create a very solid foundation to build the future of the app upon, even at this stage. If they keep this course, they can build something that is more flexible and powerful than many others in the space. Potentially, they might surpass Notion.
Why am I saying this? It starts with a tiny aside observation.
I stumbled across @dandelionmind story about Capacities compared to Obsidian recetly and read it with general interest. (And you should give it a read if you are even vaguely interested in different tools for thought apps and their use cases by people). In the middle of the article, I stumbled across a screenshot that made me curious:
At the bottom of a type’s list of properties, there is a property “Notes” of type “Blocks”. I found that intriguing and started to dig deeper. After getting my own account and starting to play around in the software, the dominoes started rolling.
In Capacities, there are no folders or subpages like in Notion. Similar to Anytype, the foundation of data storage in Capacities are single nodes of a graph. Capacities calls these node primitives “objects”. Each object is of a certain type that gathers all of its objects in a tabular database with a type-specific schema of properties.
So far, so Notion-like.
Where matters diverge is that Capacities models any block content (text and other features just like you would find them in Notion, Anytype, Craft, or other such apps) is itself stored in a property of the object. And Capacities lets us add new such (effectively multi-line text) properties to the schema of an object.
We can have metadata-labeled deep text content in Capacities.
This revelation blew my mind. Sure, at present we cannot do much with this in terms of database processing or automation logic. But it opens up labeled text options now, with many potential options that can build upon this feature in the future. Modelling some type as having multiple clearly separate contexts (such as say, claims, with supporting and refuting evidence) is possible right now.
The only application that I am aware of that decomposes the idea of metadata-labeled text attached to an object so far down into just being its own not-at-all-special type is Tana. Here various fields can contain multiple child nodes, that share one field and its semantic label, so that some structured information of a node can grow freely and be captured in representations like tabular views.
Similarly, we can find familiar single or multiple selection properties, and like in Anytype, by default these draw from a global list of tags. However, in capacities, the single- and multiple-choice pickers can draw from more than just the tags; they can draw from any type in your workspace. They can draw from your pages, books, list of people or whatever else constraint you have. Capacites simply subsumes the different ideas of one or multiple “things” or references to other objects into two direct, foundational properties — and does not even bother with anything else special.
This is decomposition in action. The developers of Capacities have looked at what they are actually modeling with various features you also find in other apps and used this insight to build really fundamental, atomic operations for structuring and annotating objects. The special structures that emerge from this are created by the users, not enforced by the programming. In creating more choice to constraint, they have created a more powerful software.
There are other things that Capacities.io does well. It supports tags in text blocks, which lets you decompose the content of one page into several different sets. This combines very well with the fact that any type is also a database of the objects and blocks it is used on, and that those tag databases automatically show what other tags are often used together with the tag.
Capacities Daily notes serve many purposes. Any properties or inline links to the day of the daily note automatically appear as a reference (and blocks are rendered as transclusions). If you add a time to a date property, you actually get a chronological timeline for the day. There are automatic lists of all new objects created on that day. If you need a place to put information, if there is nowhere else, just like in Roam and Logseq, the daily note is there for you. (The integrations to send text to the workspace via email and telegram append to the daily note, incidentally)
Every type in Capacities comes not only with the classical database view, but also a dashboard where, as of a recent update, you can not only see recently opened objects of any type but also the types
- without collections
- tags
- and backlinks(sic!)
Objects can be grouped into intra-type collections to help with building structure, where using links between notes is insufficient. (Linking is arguably strictly superior to folders — folders let objects only belong to a single hierarchy, whereas most information is likely relevant in multiple contexts and heterachies.) Objects can be part of multiple collections at the same time. Multiple-type collections, like in Anytype are not available.
Every window you work with comes with history breadcrumbs at the top, showing you the pages you came from by clicking on links (be they object references, a tag, a date link…). Oh, there are tabs in Capacities, so if you need to jump between different objects, you can.
The local graph only shows directly linked objects by default, but click “show more” in the bottom left, and the graph will expand to show the second-order links (links of files linked to) for your object. This is a great design choice and really elevates the graph as a useful tool in its own right, not just to understand the immediate context but also the intermediate context and see relations you otherwise would not. (Obsidian does have this too, but I still think it is worth mentioning.)
References to other objects in Capacities, if made at the start of a block, turn into special blocks, which can, among other things, be rendered as a transclusion you can fold out and edit within right from the embedding document. With a Believer subscription, you get the same for individual blocks.
And all of this is accessible to us right now. Tana is still in waitlist beta, and while they are arguably more powerful for note ontologies than Capacites, they also do not seem much interested in the private user. Tana is also a pure outliner (and does not have some of the great capabilities that Logseq and the like can leverage to help you connect information; see the conclusion analysis of my article about outliners), whereas Capacities lets us do some very good long-form writing and visual formatting.
That said, Capacities too does not let us define implicit links and find files by unlinked mentions, and if you want to create a true universal studio for the mind, that capability is, in my opinion, foundational.
The developers of Capacities have really understood analyzing their software and seem to have a deep understanding of how they do things and why. This has empowered them with insights to lay the foundations for much more powerful software later. Tools like Notion and Anytype have a tendency to smother us in special relations and tools — but those have narrow use cases and end up as restrictive as they are empowering. Capacities opens the gates wide and hands the user the fence poles for them to place… while giving every tool to create structure some great discovery options out of the box. Getting lost and unable to find some piece of information thus gets very unlikey.
Capacities is not perfect. At present, it has no kanban boards, though this is anticipated as a feature of the upcoming task management capability. Being able to restrict selections to collections or open them to multiple types would be nice. And Tana lets one node have multiple supertags, creating composites of properties on an object — this is the one feature idea I doubt Capacities will ever have.
But there is such a great foundation for Capacities to build on, both in what they have created and in how they appear to be building it. They seem to understand the interplay of data, structure, discoverability, and letting the user build workflows on a set of truly universal atoms better than most. Maybe one of them has read some ink-and-switch? I expect what they will introduce going forward is going to continue this style.
I am excited to see where Capacities will go. It is not the one universal software for me — my knowledge work remains centered in Obsidian and will for a while yet — but I am giving it a spin for structured project management at the moment. Let us see where the journey leads.
