From Bookmarks to Datoms
We all have that folder. "Read Later." "Research." "Cool Stuff." The graveyard of good intentions.
Browser bookmarks are dead data. They live in a silo inside Chrome or Firefox. They are hard to search, impossible to program against, and don't connect to anything else in your life.
A recent XDA Developers article highlighted a tool called buku. The author replaced their browser bookmarks with a terminal-based knowledge management tool.
It was a massive improvement. But we can go further.
Here is how we build the ultimate knowledge manager on Datom.world.
The Evolution of the Bookmark
Level 1: The Browser Silo
Chrome stores bookmarks in a JSON file. Firefox uses SQLite. To access them, you open the browser manager. Sync is handled by their proprietary cloud. You don't own the data; you rent access to it.
Level 2: The CLI Liberator (buku)
The buku tool (described in the XDA article) moves bookmarks into a local SQLite database managed by you. It offers:
- CLI access: Scriptable, greppable, fast.
- Tags: Better organization than folders.
- Ownership: It's your file.
- Portability: Works on any distro.
But it has a fatal flaw: It's still just a file. To sync it between your laptop and phone, you need Dropbox, Git, or a self-hosted server. Integrating it with your notes or tasks requires hacking.
Level 3: The Datom Stream
On Datom.world, a bookmark isn't a row in a database. It's an event in a stream.
When you bookmark a site, you emit a datom:
[entity-id :bookmark/url "https://datom.world" tx-id meta-id]This subtle shift changes everything.
Why Streams Beat Databases for Knowledge
1. Sync is Native
With buku, syncing is an operations problem (cron jobs, git push).
With DaoDB, syncing is the default state. Your laptop emits the bookmark datom. Your phone's DaoDB instance subscribes to the stream. The merge happens automatically via CRDTs. No conflicts, no servers to manage.
2. Stigmergy: Bookmarks as Signals
A bookmark is rarely just "save this URL." It's a signal: "This content is valuable to me."
In a database, that signal sits idle. In a stream, agents can react to it.
- The Archivist Agent: Sees a new bookmark datom. Fetches the page content. Saves it to IPFS or local storage. Now you have a permanent offline copy.
- The Tagger Agent: Analyzes the content. Suggests tags based on your previous bookmarks. "You tagged similar posts as #architecture."
- The Graph Agent: Connects this bookmark to your Logseq notes. "This article references the concept you wrote about yesterday."
3. Universal Access
Because the data is in DaoDB, it's queryable by anything.
The CLI View:
$ dao query '[:find ?url ?title :where [?e :bookmark/tag "clojure"] [?e :bookmark/url ?url] [?e :bookmark/title ?title]]'The Web View (DaoFlow):
A reactive dashboard that visualizes your reading habits. Not a separate app, just a query rendering your stream.
The IDE View:
Your code editor can query your bookmarks to find documentation you saved months ago.
Building a Bookmark Stream
We don't need to write a complex application. We just need to define the schema and the streams.
The Schema
In Datom.world, schema is minimal.
{:bookmark/url {:type :string :unique true}
:bookmark/title {:type :string}
:bookmark/tags {:type :ref :many true}
:bookmark/created-at {:type :instant}}The Ingest
A simple browser extension acts as the emitter. It doesn't store data; it pushes datoms to your local DaoDB instance.
The Query
Finding what you need becomes a Datalog query:
[:find ?title ?url
:where
[?e :bookmark/tags ?tag]
[?tag :tag/name "distributed-systems"]
[?e :bookmark/url ?url]
[?e :bookmark/title ?title]]The Lesson
Tools like buku are excellent because they move data from applications (browsers) to user space (files).
Datom.world moves data from user space to agent space (streams).
When your data lives in streams, applications dissolve. You don't need a "bookmark manager app." You need a way to emit bookmarks and a way to query them. The "app" is just a temporary view on a permanent stream.
Stop managing files. Start emitting datoms.