Read Later? Or Read Never? So I Built Bookmark Conversations

I have a confession to make. I’m quite good at collecting interesting websites, articles and blog posts. I’m considerably less good at actually doing something with them. I suspect I’m not the only one. There are plenty of excellent bookmarking and read-later services. Pocket was a well-known example until Mozilla shut it down in 2025. Services like Raindrop.io (https://raindrop.io/), Wallabag (https://wallabag.org/) and Karakeep (https://karakeep.app/) offer different ways to collect, organise and rediscover things you’ve saved.

But there’s something about the whole concept of read later that bothers me. Far too often, it becomes read never. At least: for me. I save an article because something about it catches my attention. Perhaps it’s an unusual idea, a small open-source project, or somebody experimenting with a completely different way of using the internet. I fully intend to return to it. But then another interesting link appears. And another. Before long, I’ve built a rather impressive collection of things I may never look at again.

What if bookmarks could talk to each other?

That question eventually led me to a little experiment I’ve been building on my Linux laptop. I call it Bookmark Conversations. The idea is quite simple. Instead of treating bookmarks as individual items waiting to be read, why not treat them as a collection of ideas that might have something to say to each other?

Okay, that might sound a little abstract. Imagine saving an article about someone running a tiny personal website. A few weeks later, you bookmark something about alternative internet protocols such as Gopher or Gemini. Somewhere else in your collection is a story about people building their own little online communities. Individually, they’re interesting links. Together, they might suggest a bigger story about people trying to make the internet more personal again. That’s the kind of connection I want Bookmark Conversations to discover. A connection I might never have thought of myself.

My bookmarks are already in Obsidian a.k.a. Markdown

I use Obsidian (https://obsidian.md/) to collect bookmarks, along with occasional notes about why I found something interesting. I wanted to keep doing exactly that. No new bookmarking service, no additional inbox, and certainly no need to move everything into another proprietary system.

Bookmark Conversations simply reads the bookmarks from my Obsidian vault. It retrieves the articles, analyses their contents and looks for unexpected connections, interesting contradictions or questions worth exploring. Yes, it uses AI (running locally on my laptop), but not to write summaries of everything I’ve saved. There are already plenty of tools that can do that. I’m much more interested in the relationships between things. And importantly, it doesn’t change anything in my Obsidian vault. The application is completely read-only, runs locally on my Linux machine and stores its own data separately.

A small discovery every morning

The current version runs automatically. Every morning, it checks my bookmarks, processes new material and searches for possible discoveries. Around 10 o’clock, I receive a desktop notification telling me what it found.

Sometimes there’s nothing new. That’s fine. I’d rather have no discovery than a completely artificial connection between two unrelated articles. When something interesting does appear, I can open a small dashboard to see why the application thinks the connection matters, what the original sources actually say and which questions might be worth investigating further. I can also save a discovery as a Markdown file. That means I can use it in Obsidian, develop it into a blog post, or simply keep it for another day.

A different relationship with bookmarks

Bookmark Conversations is still an experiment. I’ve been through quite a few versions already, fixing problems with retrieving articles, improving the quality of discoveries and making sure the whole thing can run unattended. It’s now in a longer test period, so I don’t yet know how useful it will prove to be. But I like the underlying idea. And there’s already a promising sign: Bookmark Conversations has found its first genuinely interesting connection between bookmarks that, at first glance, seemed to have absolutely nothing to do with each other. It’s exactly the kind of unexpected discovery I was hoping for, and one I might never have made on my own.

Most bookmarking tools help us collect information. Some help us organise it. Others remind us to read what we’ve saved. What I’m trying to build is something slightly different: a tool that helps me think with the things I’ve collected. Because maybe that’s the real problem with read later. We assume that the value of a bookmark lies in eventually reading that particular article. But maybe some of its value comes from the connections it can make with everything else we’ve discovered.

I don’t necessarily need another app telling me I have 500 unread articles. I’d much rather have one occasionally whispering: Hey, remember those two things you saved a few weeks apart? I think there’s something interesting going on here.

There Is More to the Internet Than the Web

For most people, the internet is the web. You open Firefox, Chrome or whatever browser you happen to use, type something into the address bar and off you go. Websites, Google, YouTube, online shops, news sites, blogs, social media. It all happens in a browser, so internet and web have gradually become almost interchangeable words.

Except that they aren’t. The web is just one way of using the internet.

Once you start looking beyond the browser, you quickly discover that there are surprisingly many other ways to use this enormous network we call the internet. Some are decades old. Others are relatively new. Some have tiny communities compared with the web. But that doesn’t make them less interesting.

Before everything became a website

Take Gopher. Gopher dates from 1991, just before the World Wide Web really started taking off. Instead of websites filled with graphics, menus, advertisements, JavaScript and cookie pop-ups, Gopher mainly gives you simple hierarchical menus containing documents and links. It is very basic. Which, oddly enough, is precisely what makes it interesting today.

There is still an active Gopher world — usually called Gopherspace — containing personal pages, archives, articles, software and all sorts of other material. You obviously don’t browse those with Chrome. You use a Gopher client. I use Lagrange (https://github.com/skyjake/lagrange), for example, which makes exploring Gopher remarkably easy. Lagrange is actually useful for another alternative protocol as well, but more about that in a moment.

If you want to start exploring Gopher, Gopherproject at https://gopherproject.org/ is a useful starting point.

After using Gopher for a while, something interesting happens. You stop wondering where all the graphics are. You simply start reading.

And then there is Gemini

Perhaps even more interesting is that people aren’t only keeping old internet technologies alive. They are also inventing new ones. One of my favourites is Gemini. Gemini appeared around 2019 and deliberately takes a very different approach from the modern web. A Gemini page — usually called a capsule rather than a website — is mostly text.

The protocol and its document format are intentionally simple and leave very little room for the sort of complexity that has accumulated around the modern web. That means no giant JavaScript frameworks. No advertising networks following you around. No autoplaying video appearing halfway through an article. No newsletter window suddenly covering the text you were trying to read. Mostly, you get the information you came for.

Gemini is tiny compared with the web, obviously. But there are thousands of Gemini capsules containing hundreds of thousands of pages. That is more than enough to spend quite a bit of time exploring. You can use Lagrange to do that. It supports both Gemini and Gopher, which makes it a convenient way to start exploring this alternative internet without having to install several different clients.

But the numbers aren’t really the interesting part. What makes Gemini fascinating is the idea behind it. What if we looked at what the web has become and started again? And what if, this time, we deliberately kept things simple?

Spartan goes even further

There is also Spartan, a newer and even simpler protocol inspired by ideas from Gemini, Gopher and HTTP. The philosophy is much the same: keep the protocol extremely small and avoid gradually rebuilding all the complexity of the modern web.

Again, Spartan isn’t going to replace the web. That isn’t really the point. For decades, computing has largely worked from the assumption that more powerful computers and faster networks give us room to build increasingly complicated software. Faster processor? Great. Let’s add more code. More memory? Excellent. Let’s use that too. Faster internet connection? Even better. Now the page can download fifty additional scripts before showing me an article consisting of 800 words.

Projects such as Gemini and Spartan ask almost the opposite question. What could we build if we deliberately didn’t use all that power?

Or build a different network altogether

And then things get even more interesting. Because Gopher and Gemini still operate using much of the internet infrastructure we already know. But you can go further. There are projects that rethink parts of the network itself. Take Yggdrasil (https://yggdrasilnetwork.org/). Yggdrasil is an experimental decentralised routing system that can create end-to-end encrypted IPv6 networks. Computers running Yggdrasil can connect directly or establish peerings across existing IP networks. The result is something that sits on top of, or can operate alongside, the conventional internet infrastructure. That already feels very different from simply opening another website.

Then there is I2P or the Invisible Internet Project (https://www.i2p.net/). I2P is a decentralised, privacy-oriented network designed to allow people to communicate and publish information while making it much harder to determine where that information originates or where it is going.

There is also Hyphanet (https://www.hyphanet.org/), formerly known as Freenet. It is built around decentralised data storage and publishing and can be used to publish and access information without depending on a conventional central web server.

And those aren’t the only experiments. GNUnet (https://www.gnunet.org/en/) describes itself as a network protocol stack for building secure, distributed and privacy-preserving applications. Lokinet (https://lokinet.org/) takes yet another approach and uses onion routing across a decentralised network. It can be used both to reach the conventional internet and to access services that exist inside Lokinet itself.

None of these projects are simply “another browser”. They are attempts to rethink how computers find each other, communicate, exchange information and establish trust. And that makes them much more interesting than their relatively small user numbers might suggest.

Then there is Reticulum

An intriguing project is Reticulum (https://reticulum.network/). Reticulum is not really one alternative internet. It is a networking stack that can be used to build networks. And those networks don’t necessarily need a conventional internet connection. Reticulum can work across Wi-Fi and normal internet connections, but also across technologies such as LoRa and packet radio. It is specifically designed to keep working with very high latency and extremely limited bandwidth.

That changes the way you think about what a network actually needs. We have become accustomed to connections measured in hundreds of megabits or even gigabits per second. Modern websites are built with those connections in mind. Reticulum starts somewhere completely different. What if the connection is terrible? What if there isn’t a conventional internet connection at all? What if two computers can exchange only tiny amounts of data? Can we still build a useful network?

You don’t even need to leave the web

There is another possibility, though. Keep using the web, but strip it down. Install a text browser such as Lynx (https://lynx.invisible-island.net/), w3m (https://w3m.sourceforge.net/) or ELinks (http://www.elinks.or.cz/) and suddenly the web looks very different. Websites that depend heavily on JavaScript may become unusable, but plenty of other sites work surprisingly well. And you quickly discover something else: a lot of what we consider essential parts of a website aren’t actually necessary if all you want to do is read the information.

There are even search engines designed around this simpler web. Marginalia Search (https://marginalia-search.com/) deliberately prioritises non-commercial content and tries to help you discover websites you probably wouldn’t find through a conventional search engine. Then there is Wiby (https://www.wiby.me/), a search engine aimed at what it calls the classic web: simpler websites that feel much more like the web of years ago.

That means you don’t necessarily have to abandon the web to get away from the modern web. You can simply use a different corner of it.

Don’t forget RSS

Then there is RSS. RSS is a particularly good example because it is something many people used years ago and then somehow forgot about. I still use it every day to follow huge numbers of blogs and websites. It facilitates actually one of my (many) news feeds. Instead of repeatedly visiting twenty websites to see whether they have published something new, you subscribe to their feeds. Your RSS reader checks for updates. New article? It appears in your reader. No algorithm decides whether that article is interesting enough to show you. No social network inserts other content between the things you actually asked to follow. Use something like Feedly (https://feedly.com/) if you prefer a graphical interface. One of my favorite tools is Newsboat (https://newsboat.org/) that gives you access to RSS and Atom feeds using the terminal of your Linux laptop.

A completely different daily internet

Put a few of these tools together and something interesting starts to happen. Use Lagrange for Gemini and Gopher. Use Newsboat for blogs and news feeds. Use Lynx when you need the web. Perhaps experiment with Yggdrasil, I2P or Reticulum when you want to see what happens when people start questioning the architecture of the network itself. Suddenly, a surprisingly large part of your daily internet use can take place without a conventional graphical browser.

You could even do much of this on an old laptop running a very minimal Linux installation. Which, as regular readers of this blog can probably guess, sounds rather appealing to me.

It is not about replacing the web

None of this means I am going to stop using the web. Why would I? Just Me itself is a website. And there are countless things the modern web does exceptionally well that Gemini, Gopher or a terminal application couldn’t sensibly replace.

That isn’t the point. The important part is realising that the internet does not have to look like the web. It can be a Gopher menu. It can be a Gemini capsule. It can be an RSS feed displayed in a terminal. It can even be a plain-text document retrieved with curl. It can be an encrypted network running across Yggdrasil. It can be a decentralised service living inside I2P or Hyphanet. And it can even be a Reticulum network exchanging tiny amounts of data over LoRa.

Once you realise that, the internet suddenly becomes much bigger again. Not necessarily bigger in terms of the amount of information available. The web obviously wins that contest by several orders of magnitude. But bigger in terms of possibilities.

How About We Stop Organising Everything Like It’s 1984?

For decades, we have been organising digital information in roughly the same way. There are folders, folders inside folders, and files inside those folders. Save some bookmarks and, before you know it, you have another list. A very long list, usually.

I have always been fascinated by people who try something different. Tags are one obvious alternative. Instead of forcing something into one particular folder, you can describe it from several different angles. That is one of the things I like about the way I currently use Capacities.io (https://capacities.io/): pages, objects and tags allow information to be connected rather than simply stored somewhere in a hierarchy. Word clouds are another simple example. They don’t necessarily organise information better, but they do allow you to look at it differently.

And then I came across Pixel Area (https://pxlarea.com/). Pixel Area — or pxlarea — takes yet another approach. It is basically a 100 × 100 grid containing room for 10,000 links to websites. Instead of browsing through a directory or looking at a ranked list of recommended sites, you wander around a field of pixels. Each claimed square represents someone’s blog, digital garden, photo journal or other personal corner of the web. Move around, discover a pixel and see where it takes you.

There are deliberately no rankings and no “top blogs”. Sites can have tags, so you can make pixels matching particular subjects appear like a little constellation. There is also a random option if you simply want to see where you end up. If a site has been updated recently, Pixel Area can show that too. It turns discovering websites into something much more spatial and slightly more accidental than scrolling through yet another list.

Kobala (https://kobala.nl/startpagina-functies/?utm_source=chatgpt.com) is another example of a different way to organise links. Instead of relying on a traditional bookmark list hidden somewhere in your browser, it lets you create a visual start page made up of blocks for websites and other online resources. It is a simple idea, but that is exactly what makes it interesting: the information is still basically a collection of links, yet changing the way those links are presented can make them much easier to scan and use.

And let’s not forget Start.me (https://start.me). Start.me is yet another take on the browser start page, turning bookmarks, feeds, notes and widgets into a visual dashboard of blocks. Instead of digging through folders or long bookmark lists, you can arrange the information you use most often in one clear, customisable overview.

I like all these ideas. Perhaps one of the most fascinating is Surf by Berlin-based Deta (https://deta.surf/). Surf describes itself as an intelligent notebook that brings your files and the web into your stream of thought. The interesting part for me was the way it blurred the distinction between my own information and information somewhere else. You could put your own files, notes, PDFs, websites and other material together inside one notebook and then use AI on top of that collection. Instead of constantly jumping between a file manager, browser, notes app and AI tool, the notebook became the place where all those different kinds of information met. Unfortunately I had to stop using Surf when I moved from macOS to Linux.

And while writing this post I discovered something rather nice: that is no longer true. Surf is now available for Linux and Windows as well, and Deta has made its core open source. It is also local-first, with notes and resources stored on your own device (https://github.com/deta/surf/blob/main/docs/INSTALL.md). Hmm. I may have to have another look.

Is this an exhaustive overview of alternative ways of organising and presenting information? No absolutely not. I haven’t even mentioned things I wrote about earlier, such as TabFS (https://justme.website/content-creation/maybe-screenshots-are-the-simplest-personal-knowledge-management-tool-we-already-have/) or Screenshot Conf (https://justme.website/content-creation/i-went-looking-at-a-conference-about-screenshots-about-what-and-found-a-filesystem-for-browser-tabs/). And there must be hundreds of other experiments I have never heard of.

That is actually the part I find most interesting. We have had folders, files and lists for such a long time that they can start to feel like the natural shape of information. But they aren’t. They are simply conventions we became used to. Every now and then someone comes along and asks: what if we did this differently?

At the moment, Capacities, and their pages and tags work well for me. Pixel Area probably isn’t going to replace that. Nor do I think Pixel Area is the ideal way of navigating information or discovering websites. But that isn’t really the point. Someone builds Pixel Area. Other people try it. Someone sees an interesting idea in it, combines it with something completely different and builds something new. Then someone else improves on that. And step by step we discover, hopefully, slightly better ways of dealing with all the information we keep creating.

Pebble’s Index 01 Is Exactly the Kind of Smart Device I Want

One of the nicer surprises waiting for me when we returned from our summer holiday at the Mediterranean was a small package from Pebble. Inside was the Index 01 (https://repebble.com/index).

I have been using it for a few weeks now and, although calling it a smart ring is technically correct, it is probably not what most people imagine when they hear that term. There is no screen. No heart-rate sensor. No sleep score. No attempt to tell me whether I am stressed, healthy or sufficiently recovered from yesterday. It is basically a ring with a button and a microphone. And I really like it.

Press, speak, forget about it

You wear the Index 01 on a finger — Pebble suggests the index finger, although other fingers can work as well — and use your thumb to press the small button. Then you bring the ring close to your mouth and say whatever you want to remember. “Buy buttermilk.” “Order new sports shoes for my daughter.” “Look up that article about industrial robots.” That sort of thing. The recording is transferred over Bluetooth to the Pebble app on your phone. There it is converted to text and an LLM works out what you meant. A request to buy buttermilk can end up on a shopping list, while the sports shoes become something to remember or do. If the software puts something in the wrong place, you can simply move or correct it in the Pebble app. But in my experience that hardly ever happens.

Dutch works just fine

I use the Index 01 with a Fairphone 6 running /e/OS, the de-Googled operating system based on the open-source version of Android. The same Pebble app connects both my Pebble smartwatch and the Index 01. So far the combination has worked remarkably well. The Bluetooth connection is reliable, activating the microphone is simple and I speak all my messages in Dutch. The speech recognition and LLM have no problem with that. In practice, my little spoken notes almost always end up where I expect them to.

There is something slightly magical about thinking I must remember this, pressing a button, saying five words and then carrying on with whatever I was doing. No phone to unlock. No app to find. No keyboard. That small reduction in friction makes a surprisingly big difference.

No charging

There is another unusual design choice. You cannot charge the Index 01. Pebble put a non-rechargeable battery inside and designed the device for extremely low power consumption. Depending on usage, Pebble says it should last for years. Founder Eric Migicovsky has described his own usage pattern as potentially giving around two years of operation.

Once the battery is empty, it is empty. That sounds strange in a world where seemingly everything needs to be charged every evening. But it also fits the product. The Index 01 isn’t trying to be a tiny computer on your finger. The ring records your voice and sends it to your phone. Most of the clever processing happens there.

I paid roughly €70 plus shipping for mine, although I may have had an early-adopter price. The current listed price is $75, with Pebble indicating a higher regular price later.

Now I want it in Capacities

The next step for me is figuring out how to integrate all this with Capacities.io (https://capacities.io/), which I use as my personal knowledge management system. Capacities has quite a steep learning curve. At least it did for me. Once you begin to understand how it allows you to organise information, however, it becomes very useful. At the same time, I am the first to admit that I am probably still using only a small percentage of what Capacities can actually do.

So perhaps the Index 01 can become part of that workflow as well. Pebble already supports external integrations through webhooks and MCP, the Model Context Protocol. The company explicitly designed the system so people can route notes and actions into their own tools. That sounds promising. I have no idea yet exactly how I will connect it to Capacities. But finding that out seems like a good subject for another blog post.

Technology that mostly leaves me alone

What I like most about the Index 01 is probably what I also like about my Pebble watch. Showing me the time aside, my Pebble watch is mainly there for notifications. That means I don’t have to pick up my phone every time something happens. I decide which notifications are important enough to reach my wrist and largely ignore the rest.

Don’t get me wrong, Pebble does have a huge collection of watch apps and watchfaces — thousands of them — but I have barely explored them. I don’t really need to. For me, the combination of the Pebble watch and Index 01 already does something much more valuable. It creates a relatively quiet technological environment. No constant demands for attention. No device desperately trying to become the center of my life. Just the notifications I have decided I want — plus a small ring that lets me capture a thought before I forget it. That is about as much “smart” as I need from a ring.

Here is the original video in which Pebble founder Eric Migicovsky introduced the Index 01:

Maybe Screenshots Are the Simplest Personal Knowledge Management Tool We Already Have

Via my recent post, I Went Looking at a Conference About Screenshots (About What?) and Found a Filesystem for Browser Tabs (see here: https://justme.website/content-creation/i-went-looking-at-a-conference-about-screenshots-about-what-and-found-a-filesystem-for-browser-tabs/), I seem to have stumbled into a new world. Or perhaps I should say that I have returned to an old one. Plain text files, bitmap images and other simple file formats have been around for as long as I can remember. They are boring in the best possible way: simple, understandable and usually not tied to a particular service or vendor. But after years of apps, platforms, cloud services and increasingly complicated workflows, I had more or less stopped thinking about them.

Then I discovered Screenshot Conf. And that made me look at screenshots differently.

A screenshot isn’t necessarily just an illustration

I take screenshots all the time. But I mostly use them as illustrations. Something interesting happens on my screen, I capture it, crop it and use it somewhere. That is about it. But screenshots can obviously be much more than that. They can be artistic objects. They can become part of collages. They can document software, interfaces and moments in digital history.

Even more interesting to me, however, is the idea of the screenshot as a knowledge object. You can capture part of a technical report. A diagram. A complicated mathematical formula. A paragraph from a website. A table from a PDF. A particular state of an application. Or simply something you don’t yet know what to do with, but suspect might become useful later.

The screenshot preserves exactly what you saw. The problem is that ordinary screenshots are fairly dumb. There may be a beautifully readable paragraph inside a PNG file, but as far as the filesystem is concerned, it is still just an image.

Making screenshots less dumb

This is where things become more interesting. Omar Rizwan, one of the people behind Screenshot Conf (https://screenshot.arquipelago.org/) and also the creator of TabFS (https://omar.website/tabfs/), made a tool called Screenotate for macOS and Windows (https://screenotate.com/). Screenotate doesn’t merely save the image. It uses OCR to recognise the text inside the screenshot and can also store information such as the window title, URL and time of capture. The result is searchable. Rizwan designed it so that screenshots remain on your own computer, with each capture stored as a self-contained HTML file.

That changes the nature of a screenshot quite dramatically. Imagine capturing one interesting equation from a 120-page research report. Normally you would later have to remember which report was that again? With a tool that also stores the source and recognises the text, the screenshot becomes part of a searchable personal archive.

That started me looking for other tools that do similar things. And there are quite a few.

Linux: Flameshot, NormCap and metadata

On Linux, Flameshot (https://flameshot.org/) is probably one of the better-known screenshot tools. It lets you annotate a screenshot immediately with arrows, text, highlights, shapes, blur and other elements. It also has a command-line interface, which means it can become part of scripts and more elaborate workflows.

Ksnip (https://ksnip.com/) takes a similar approach and combines screenshots with annotation tools.

For OCR, I particularly like the idea behind NormCap (https://dynobo.github.io/normcap/). Instead of capturing an image, you select a piece of the screen and NormCap tries to recognise the information inside it and copies the result as text. It is available for Linux, Windows and macOS and uses Tesseract OCR.

And if you really want to treat screenshots as proper information objects, there is ExifTool (https://exiftool.org/). It can read and write metadata, including XMP metadata in PNG files. That means you could add things such as descriptions, tags or other information to screenshots and potentially automate that process with scripts.

So a Linux workflow could be surprisingly simple: Take the screenshot with Flameshot. Annotate it. Extract useful text with NormCap. Add metadata with ExifTool. Suddenly a PNG is becoming something rather more useful.

Windows has some very good options too

Windows users have PowerToys Text Extractor (https://github.com/microsoft/PowerToys/blob/main/doc/devdocs/modules/textextractor.md), Microsoft’s open-source OCR utility. Press a keyboard shortcut, draw a rectangle around something on screen and the recognised text is copied to your clipboard. It even works on text displayed inside images or videos.

There is also ShareX (https://getsharex.com/), which has developed into much more than a screenshot utility, with capture, editing and workflow features. And, of course, Screenotate itself works on Windows too.

And on the Mac

macOS already does quite a lot with screenshots and text recognition itself, but there are some interesting specialised tools.

Shottr (https)://shottr.cc/, for example, combines screenshots, annotation and OCR. You can select text that normally isn’t selectable, recognise it and copy it directly to the clipboard. It can also combine screenshots, pin them on screen and add annotations.

CleanShot X (https://cleanshot.com/) takes a similarly broad approach. It can extract text from screenshots and open existing screenshots directly in its annotation environment.

Screenshots as a personal knowledge layer

What interests me most is not really which screenshot application has the longest feature list. It is the underlying idea. We usually think about screenshots as disposable images. Take one, send it to someone, use it in a blog post and forget about it.

But what if screenshots become part of a personal knowledge system? You could capture an important paragraph without copying an entire document. Save a formula exactly as it was typeset. Preserve a table together with its source URL. Add keywords. Extract the text. Annotate why you thought it was interesting. Search everything later.

When I was still using an iPhone, I deliberately set the system language to English. One of the reasons was Apple Notes. Set to English, it gave me access to OCR features that were surprisingly useful for collecting information. I could be reading a magazine, come across a paragraph or even a complete article that I wanted to keep, photograph it directly from Notes and have the app turn the image into editable text inside the note. In a way, it was exactly the same idea: capture something visually first, then use OCR to turn the interesting part back into text that you can search, store and work with later.

Screenshots are fundamentally just files. That means you are not necessarily dependent on one enormous knowledge-management application to do all this. The screenshot itself can become the basic object. That feels strangely old-fashioned. And perhaps that is exactly why I like it.