Flow-State Idea Capture Vs. Organization

By Mike Levin

The Tension Between Organization and Idea Capture

Organization is key. But then so is idea-capture.

These two things are opposing forces, because organization is going to have a lot of fidgeting with the flow-breaking bells and whistles of tools (Obsidian, Notion, Trilium, etc). It’s not the free-flowing state of stream of consciousness writing, but the rewards will be great. What you’ve done in your more spontaneous free-flowing state becomes refined and polished, and indeed accessible to other people at all. And if your purpose is to share, profit or otherwise benefit from it beyond just the “having processed it”, then organization is key.

The Different States of Mind

There’s lots to say about both the free-flowing state of idea-capture and the more judgemental and critiquing state of organization, but even just that is saying a lot. The former is a transcendent mental state. The movie Soul got into it. So many people tell you to live in the moment, but is that what musicians do when they’re playing their instruments? Is it what athletes do when they’re making split-second decisions, or woodworkers when they’re crafting? There’s different modes of being and don’t let anyone live in the moment-shame you. Often times, that’s just people with attention deficits jealous of those who can achieve flow state.

The Magic of Flow State

So, it’s good to idea-capture in that flow-state, which is where the stereotype of having all your best ideas when you’re in the shower or driving. Your mind tends to just wander, free of all the attention-fixing trappings of the daily grind, and you daydream. You go into a waking dream-state and synapses fire in your brain that usually don’t because you’re on-guard by the waking cognizant mind. When that guard goes down, dots can connect and your true inner brilliance, which isn’t easily forced to perform, can shyly poke its head out and suggest a few things.

Avoiding Tool Snags

Don’t get caught in the tool snag! Tools snag! If you’re not fully expert at using those idea-capture tools, whatever they may be from finding a pen and paper to some high tech gadget, if it’s not automatic and spontaneous, that idea may get lost. Fortunately, its probably not lost forever. If you had a good idea once, you’ll likely have it again. The idea is to be more prepared the next time by pushing whatever idea-capture tools you’re using from the realm of unavailable or awkward to the realm of always-there and like extensions of your body—gain, the concept of musicians or athletes with their equipment.

The Problem with Premature Organization

Even stopping to thing about labels is a bad idea. That’s changing the task from pure idea-capture to the critical judgement process, often prematurely. Systems that force you to “give something a name” first are doing you a disservice. In principle, you want a reverse chronological queue. That is, you push new ideas in at the top and it pushes everything else down. Typical paper journals in notebook form get close, but they force you to look at your entire history of journaling, at least to find the last page where you left off as the first page where you start chronicling a new day. Blogging software, Google Keep and the stuff built into iPhones now as a default app does a better job. You push new thing in at the top, pushing old stuff down with no need to stop and label.

The Importance of Follow-up

In idea-capture systems that require labeling, you can always just use “New Note” and organize it into some sort of Inbox so you can go back and sort it out later. The idea is to reduce friction. And really it doesn’t even need to be one single tool. More importantly is the habit and ability to capture an idea under almost any condition. Electronically, you can always just shoot an email off to yourself, and non-electronically, you can always jot a note on your hand. Whether in your inbox or on your hand, you’re going to look at it again, and the follow-up habit there is what’s important.

The Power of Vim

For me, that’s vim. These days, it’s actually NeoVim, but it might as well be vim, which might as well be vi, which goes back to the mid 1970s, with a history actually a decade older to the rise of single-line editors. Whatever is going on with that program and all the descendants and variations in its lineage, it hit a fundamental. By the way, it was the same Ken Thompson as who made Unix itself who made one of the earliest implementations, though most credit goes to a guy named Bill Joy, the clean-up artist of Unix re-writes. So many stories to tell!

The Vim Renaissance

Suffice to say, that whole flow-state thing, yeah, vi, vim, nvim in all its variations nailed it. If there’s a “mode” that other text editors emulate, it’s going to be vim. We use the word vim over vi and nvim because it’s the implementation that caused the renaissance of that camp in the great text editor war whose origins date back so far that it makes today’s VSCode vs. Atom discussions… oh wait, Microsoft killed Atom… well then Sublime. Or Notepad++ (is that still a thing?)—well, you get it. Whole text-editor and IDE empires rise and fall, but there in the background is still vi and emacs duking it out for forever-tool dominance.

Forever Tools in Tech

Forever-tools exist in tech, I shit you not. That’s because through a combination of hitting various fundamentals, getting battle-hardened and withstanding the test of time, they become the underpinning dependencies that everyone else uses—and manage to avoid enshitification! Oh don’t get me wrong, terrible versions do pop into existence here and there as they inevitably will when anyone can fork the codebase and do such nonsense as adding graphics to vim, but for the most part a kind of enshitification-proofing critical mass has been achieved such that even the death of the original author can’t put a dent in its popularity, support, or continuing dominance.

The History of Vim

As the phenomenal luck of the cosmos happens to be, Ken Thompson and Bill Joy are still with us, the authors of vi and it’s mainstreamed re-write, respectively. However, the Dutch engineer Bram Moolenaar who caused the vi(m) revival by porting an improved version to the Amiga computer circa 1988 (but popularized by its distribution on Fred Fish public domain software disk #591 in 1991)… uh, Perplexity?

Perplexity: Vim, which stands for “Vi IMproved,” was first developed by Bram Moolenaar in 1988 for the Commodore Amiga. The initial version was called “Vi IMitation” (Vim) and was inspired by the Stevie editor. The first public release of Vim, version 1.14, occurred on November 2, 1991. This version was distributed on Fred Fish disk #591, part of a series of disks that contained various freeware software for the Amiga[1][2][4][7].

Fred Fish was known for curating and distributing software through his disks from 1986 to 1994, which were widely circulated among Amiga users and enthusiasts[1][2].

Citations:

[1] https://pikuma.com/blog/origins-of-vim-text-editor
[2] https://amitopia.com/vim-was-originally-developed-for-the-amiga/
[3] https://courses.cs.washington.edu/courses/cse490h1/19wi/exhibit/vim.html
[4] https://jovicailic.org/2014/06/the-history-of-vim/
[5] https://simple.wikipedia.org/wiki/Vim
[6] https://twobithistory.org/2018/08/05/where-vim-came-from.html
[7] https://en.wikipedia.org/wiki/Vim_(text_editor)
[8] https://datagubbe.se/fish/

The eMacs Legacy

Uh yeah, so the most powerful wizards of tech were using eMacs all that time, really never giving it up nor it going away, with the improved versions becoming phenomenally incomprehensibly improved. There’s jokes here about eMacs being a fine operating system occasionally used for text editing. But it’s one of those wizardly ways that has always eluded me in my life, the same as the LISP programming language on which most of this stuff is derived, from the precursor of the sometimes famous MIT Media Lab where the first AI-winter was born. LISP is like the bizaro-world alternative to the Unix/C one-two combo that knocked the world into the modern age. LISP and The Amiga have a lot in common.

The Rise of Vim

So, vim which had its renaissance on the Amiga vastly improved on vi and was quickly ported to Unix, the PC and every other platform, its macros, syntax color-coding and really just large undo buffer providing enough killer features to displace vi as the default, something that often happened because vi is part of the Unix standard, but people spinning Linux distros found it hard to include vi when vim was available. And so, the great text-editor war was back on, and vi/vim’s unique muscle memory habit-forming nature got to be spontaneously rediscovered by newer and newer generations of coders.

Flow State and Idea Capture

And that’s where the flow-state and idea capture power of vim comes into play. If you’ve ever used Microsoft Word, Google Docs, or even just Notepad or TexEdit to capture ideas, then you know the cognitive overhead of it all. Find a computer to work on. Make a new document. Give it a name. Where to store it? How to organize it? Will it get lost? Should you spend time formatting it? How do you know you will ever look at it again?

The Power of Continuous Writing

Well, I’m here to tell you that if you start writing a single text-file today and never stopped writing in it for the rest of your life, you could not produce something that was difficult for vim to load. In fact, if you wrote like Steven King slamming out… uh…

Me: If a human being sat down and started typing when they woke up and was a relatively fast typer, and didn’t stop for the whole day, how much could they type?

Perplexity: To estimate how much a human could type in a day, we can use average typing speeds and the number of hours available for typing.

Average Typing Speed

• Fast Typist: A relatively fast typist can type at speeds of 80 to 100 words per minute (wpm). For this calculation, let’s use 90 wpm as a representative speed.

Daily Typing Duration

Assuming the typist starts typing upon waking and continues without breaks for a full day:

• Hours in a Day: 24 hours
• Typing Hours: If we consider a more realistic scenario where the person types for about 16 hours (allowing for sleep and basic needs).

Total Words Typed

Using the formula: \(\text{Total Words} = \text{Typing Speed (wpm)} \times \text{Minutes Typed}\) Calculating for 16 hours:

• Convert hours to minutes: \(16 \text{ hours} \times 60 \text{ minutes/hour} = 960 \text{ minutes}\)
• Total words typed: \(\text{Total Words} = 90 \text{ wpm} \times 960 \text{ minutes} = 86,400 \text{ words}\)

Summary

A relatively fast typist could type approximately 86,400 words in a day if they typed continuously for 16 hours at a speed of 90 wpm. This is a theoretical maximum and actual results would vary based on typing stamina, breaks, and other factors.

Citations:

[1] https://www.asaporg.com/efficiency-skills/average-words-per-minute-typing-how-fast-is-fast-enough
[2] https://www.ratatype.com/learn/average-typing-speed/
[3] https://www.reddit.com/r/typing/comments/121whsi/average_type_speed_for_typistsenthusiasts/
[4] https://www.typing.com/blog/typing-speed/
[5] https://www.typingpal.com/en/typing-test/vitesse-frappe-en.png?sa=X&ved=2ahUKEwjjnPvF3sWKAxXXhIkEHQyqNm8Q_B16BAgKEAI

Me: If they did that for their entire life, how much text could they produce?

Perplexity: To estimate how much text a person could produce by typing continuously for their entire life, we can build on the previous calculation of daily output and incorporate a lifespan.

Daily Output

As calculated earlier, a relatively fast typist could produce approximately 86,400 words in a day.

Lifespan Consideration

Let’s assume an average lifespan for this calculation:

• Average Lifespan: Approximately 80 years.

Typing Duration

For simplicity, we’ll assume the person starts typing at age 20 and continues until age 80, giving us 60 years of typing.

• Days in 60 Years: \(60 \text{ years} \times 365 \text{ days/year} = 21,900 \text{ days}\) (Note: This does not account for leap years, which would add about 15 extra days over 60 years.)

Total Words Typed Over a Lifetime

Using the daily output: \(\text{Total Words} = \text{Daily Output} \times \text{Total Days}\) \(\text{Total Words} = 86,400 \text{ words/day} \times 21,900 \text{ days} \approx 1,895,760,000 \text{ words}\)

Summary

If a relatively fast typist typed continuously for 60 years (from age 20 to 80), they could theoretically produce approximately 1.9 billion words over their lifetime.

This is an impressive figure that highlights the potential volume of text one could generate through continuous typing!

Me: How big would a text-file containing all those words be?

Perplexity: To estimate the size of a text file containing approximately 1.9 billion words, we need to consider the average number of characters per word and the encoding used.

Average Characters per Word

• A common estimate is that an average English word is about 5 characters long. Including spaces and punctuation, we can estimate about 6 characters per word.

Total Character Count

Using this estimate: \(\text{Total Characters} = \text{Total Words} \times \text{Average Characters per Word}\) \(\text{Total Characters} = 1,895,760,000 \text{ words} \times 6 \text{ characters/word} \approx 11,374,560,000 \text{ characters}\)

File Size Calculation

1. ASCII Encoding: If the text is encoded in ASCII, each character takes up 1 byte. Therefore: \(\text{File Size} = 11,374,560,000 \text{ bytes} \approx 11.37 \text{ GB}\)

2. UTF-8 Encoding: If the text includes Unicode characters (like emojis or special symbols), the size can vary. However, if we assume most characters are ASCII (which is common for English text), it would still be close to the ASCII size unless a significant portion of the text uses multi-byte characters. For a rough estimate:

   • The size could range from about 11.37 GB for mostly ASCII to potentially larger if many multi-byte Unicode characters are included.

Summary

A text file containing approximately 1.9 billion words would be around 11.37 GB when encoded in ASCII. If it includes more complex Unicode characters, the size could be larger, depending on the specific content of the text and encoding used[1][2].

Citations:

[1] https://www.reddit.com/r/AskComputerScience/comments/18jw8uu/how_big_is_a_txt_file_with_1_billion_characters/
[2] https://stackoverflow.com/questions/62056433/estimating-size-of-a-large-text-file
[3] https://www.usmobile.com/blog/how-much-is-a-gigabyte/
[4] https://github.com/crscardellino/sbwce
[5] https://www.mark-davies.org/articles/davies_62.pdf
[6] https://www.kaggle.com/code/fanbyprinciple/pride-and-prejudice-text-encoding
[7] https://21centurytext.wordpress.com/introducing-the-1-9-billion-word-global-web-based-english-corpus-glowbe/
[8] https://opendata.stackexchange.com/questions/19711/how-can-i-get-the-english-wikipedia-corpus
[9] https://python.plainenglish.io/creating-a-custom-corpus-928789c089e7?gi=c6bd1fe4a6d8

Me: How much difficulty would nvim have any difficulty loading such a text file?

Perplexity: Neovim (nvim) can handle large text files, but the performance may vary significantly based on several factors, including file size, content, and the configuration of Neovim itself.

Performance with Large Files

1. Loading Time: Neovim has been reported to take considerable time to open large files, particularly when features like syntax highlighting or filetype detection are enabled. For instance, opening a moderately large file (1 million lines, 66 MB) with these features can take about 3 seconds, whereas a clean setup without plugins or configurations can load it much faster—around 1 second[1][2].

2. Large File Plugins: There are plugins designed specifically for handling large files in Neovim, such as bigfile.nvim. This plugin disables resource-intensive features when opening files larger than a specified size (e.g., 2 MB), which helps in navigating massive files without lag. When used effectively, it can allow smooth navigation through very large files[1].

3. Configuration Adjustments: Users can optimize Neovim’s performance by disabling syntax highlighting and other features that may slow down the loading process. For example, running Neovim with -u NONE or adjusting settings to ignore filetype detection can significantly improve loading times for large files[3].

Summary

While Neovim can open very large text files (potentially in the gigabyte range), it may experience difficulty if certain features are enabled. Using plugins like bigfile.nvim and adjusting configurations can mitigate these issues, allowing for efficient handling of large text files without significant lag or delays.

Citations:

[1] https://www.youtube.com/watch?v=64UB9Nc2QvY
[2] https://github.com/neovim/neovim/issues/19817
[3] https://vi.stackexchange.com/questions/149/how-can-i-open-very-large-files-with-good-performance

Vim’s File Size Handling

Okay, so you might need a plugin if you typed like Steven King into a single text-file for every waking hour for your entire life. But most human beings would not even begin to get near what vim/nvim could load and allow you to easily edit. So, no file-organization required! Just use reverse chronological pushing it down from the top. Master those muscle memory skills of treating type like a video-game. That’s what vim is. It’s like the video-game of text editing. Imagine if all those hours and skills people put into shooting each other virtually was put into manipulating text! That’s all tech is (most information technology, at least), text pushed around and manipulated different ways.

The Power of Flow State

So if you can push information around in a flow state, you’re golden. You’re future-proofed. It merely starts with the ability to get into the zone and do stream of consciousness idea-capture. In doing so, you’re developing all those habits that transfer over to any programming language for any challenge or problem in any problem domain, field, endeavor, hobby or interest… forever.

Now there’s an idea worth capturing, huh? And so I did! And so I did in a reverse chronological unordered state. But my first step to organizing it is just moving it over to where I share such stream of consciousness ramblings as my daily tech journal.

Organization will come soon! And through various approaches!

AI and Content Organization

One of my data science, machine learning, AI model training or what have you learning exercises will be how to step through all these daily tech journal posts and distill it down into the future-proofing book. I’ve got to do that soon, because the iron is very hot. I watch these videos about SEO bottom-feeders making millions by essentially doing this with Amazon books to sell to bored rich housewives. Ugh! How disgusting that these people are even in the same field as me. But they are allegedly making millions, so who am I to judge? I wish I could make millions thinking it through slow and methodical-like.

The Art of Organization

Yeah, so I don’t jump on that whole organization bit that turns it into monetary reward, too quickly. That’s video-editing. That’s spamming Amazon eBooks. But I should really learn from them. Being able to organize effectively and push things through the value chain in marketable and salable form is… uh, valuable? It’s like I’m caught in an artist’s trap, but in tech. But all I have to do is make the organization process of more interest to myself, and indeed more love-worthy.

Design as the Bridge

The dopamine hit or whatever it is I get from the idea capture flow-state has to also happen in that more judgemental and critical organization phase. In other words, design! Yup, that’s right. Whether it’s visual design, video editing, designing products, writing books or software, the difference between pure idea-capture, where all that raw brilliance might actually reside, and it having some meaningful impact on the world, is design.

The Refinement Process

Stopping to think and consider. Looking over what you have and what you’ve done. Distilling down the important parts with consecutive passes of review, idea-extraction, refinement and sieving. Creating outlines, organizing chunks under those outlines, and re-working those chunks into something more cohesive with excellent transitions between chunks. Taking something where the chunks started out fluid and able to be slid around and hard-wiring it into the one perfect storytelling presentation that works to communicate the most important things to most of the audience most of the time. Rigging it for success.

The Value Chain Dilemma

Yuck! It sounds exhausting! And it sounds like stuff anyone can do, because my gut tells me that all the value is in the raw material. But it’s raw material! It’s just like any value chain where raw material gets value added in each step of the supply chain. Ore gets mined. Mined ore gets refined. Pure distillations get extracted and turned over to factories and craftspeople. It gets turned into cars and jewelry and stuff. Value chain.

Journey Through SEO and XML

I don’t like the whole value chain. Parts of it frankly disgust me. And I’m a friggin search engine optimizer! I got into it because I found it easy to organize information at a time others could barely get stuff published. I used what was available at the time, something which seemed future-proof, but something which was ultimately failed. XML was all the rage then, and there were stylesheets for XML that recursively walked every object and could spit out transformed pages.

For example, if you had one long text-file, you could split it with <xsl:result-document> in a stylesheet template. Thus with 2 templates, you could first slice, then you could add style as you do today with CSS stylesheets. Back then, CSS wasn’t ready for primetime, so you layered in lots of custom non-semantic HTML. And thus you could make incredibly well-optimized websites, because you could make perfectly optimized linked-together sequences of pages, and other stupid SEO tricks that worked reliably in the age of “if you write it, they will come.” And so my predisposition to the static site generators like Jekyll that do this with markdown files today, but for the file-slicing part.

The Single Text File Approach

So one long text-file for life has its place. It’s great for personal journaling and daily note-taking in a way where you’ll never truly lose something for the rest of your life, so long as that thing you emailed yourself or that note that you jotted on your hand makes it into that text-file. But still, it’s unwieldy. It’s my old “no time to organize” mentality that has kept me a technology artisan into my mid-fifties, and not my own gallery owner or at least retired artisan, haha! But there’s time. The iron is hot. We are at the dawn of AI, and all my skills are uniquely keyed for this future. I just need to organize.

The Evolution of Note-Taking Tools

And so that gets to the other side of this discussion. We talked flow-state ad nauseam now, and it should be pretty clear I’m an advocate of vi/vim/nvim for that. You’ll idea-capture without vendor dependency on Word, Docs, Notepads or TextEdits. One text-file means you always know where to write. Adding git to the picture means it’ll always be backed up with infinite undos back to file-creation, and distributed to multiple locations so you can never accidentally lose it from hard drive crashes or switching machines, or whatnot. Mobile is a weakness here, but as I said with capture-anywhere, drop-it-in-vim later mentality, you can use whatever you like on mobile, even if it’s your email program (one of the better choices for reasons we’ll cover later).

Commercial Note-Taking Solutions

And so we’re talking organization now. These organization programs come and go. And they’re incredibly focused on making the vendors you buy them from money, locking you in, and… well, Evernote. Microsoft OneNote. Apple Notes (and now Journal and everything iCloud). More recently, there’s Obsidian which is open source but also commercial—considerably more noble. Also Notion has gone that route. It’s a good business model and I admire that and you should support Obsidian and Notion. But do know that they’re just passing fads, and if you use them for the hosting and syncing, you once again don’t really own your own data. It’s a tricky one to solve.

The Quest for Perfect Organization

I had tried various things over the years. I like memory mapping, outlining, and those transition phases between loosely organized idea-capture and something more refined. There’s software categories even specifically for that like Trello and Miro, but again, vendors trying to get your money for stuff you can do for free. For free, for sure! But forever? Free of fads?

The Emacs Solution

There is one true answer to this, but I cannot guide you down that route. Even I am not technical enough for it, and that is customized eMacs. Those who master eMacs master this sort of list-management deluxe. Anything you can image, eMacs masters can make happen. They are higher-order wizards.

The Top-Bottom Approach

For some time I tried just using “the top” and “the bottom” of the 1-text-file approach, because in one forever-growing text-file where the stuff in the middle gets forever-more lost, there are precisely 2 fixed-points that are always easy to get to. That’s the top and the bottom. In vim page-navigation, that’s expressed as gg (tapping g twice) for the top of the page and G (shift+G) for the bottom. It’s really that easy. You’re typing anything anywhere in a document, and you use these 2 keystrokes, and you can pop to the top and pop to the bottom instantly. Just put your important, organized lists there, right?

Limitations of the Top-Bottom Approach

Well, 2 problems. The top becomes not really usable for that except for the most bare minimum lists like daily forever-reminders. But for the most part that’s where you’re pushing remote chronological things in from the top. So you’d have to start each such entry underneath your lists at the top. And that’s tedious with cognitive load. It’s actually what I do, but I keep the lists very short and I use a macro to start the new entry with all the YAML-like journal entry topmatter (more on that later).

The second problem is that the lists at the bottom become a mess. If you’re working on big lists for example, they become hard to navigate always “going back up”. And if you’re looking for features like memory mapping or network graph visualizations (and the accompanying cross-document linking) like are so popular in Obsidian, you can forget it. I mean, there are ways. But they add cognitive load and are exhausting. Save your special magical ETL transforms for places where self-hosted free and open source software utilizing best practices doesn’t already have you covered.

The SimpleNote Era

At first, I thought I was looking for just a replacement for SimpleNote, the dirt-simple, instantly syncing, multi-platform software and service that was the media darling for about a month back in 2008 when instantaneous syncing was still a big deal and hadn’t found its way into everything, the way it has Google Docs and Sheets. It was a big deal then. Another piece of software called Etherpad, which is still around today, showed quite how instantaneous and simple it can be. I jumped on the SimpleNote bandwagon for mobile idea capture, and never looked back… until recently.

The Search for Self-Hosted Solutions

I was looking for self-hosted solutions just like SimpleNote to solve the idea-capture on mobile challenge. SimpleNote had a similarly dirt-simple API so when I sat down at a vim document, I simply had to hit a hotkey and it would pull the notes down from the cloud, into my notes, and subsequently into a git repo. The cognitive overhead was non-existent and the promotion of the flow-state was optimal. Unfortunately (or so I thought), there was nothing exactly like SimpleNote in self-hosted free and open source software. Everything was much too complicated, or were the “first dose free” lures of commercial software.

The NixOS Experience

And there are a bunch of choices. All roads appear to lead to Joplin, and I might be on Joplin now had their NixOS integration been a bit more trivial of an install. For you see on NixOS, installing software in most cases is as simple as adding a single line to a text-file. There’s no apt. There’s no yum. There’s no brew. Nor is there even a need for docker. You just put a line in a text file, rebuild your system (not as scary as it sounds), and that’s it. The software’s installed. Don’t like it? Remove the line and rebuild, and there’s no cruft left in your system. NixOS (and nix on Macs and Windows is the future).

You don’t really even need to put the line in your configuration.nix file to install and test the software temporarily, as these things can be done in isolated directories so you can test them out or use them quickly as a one-off without… I was going to say pollute your system, but there’s really no polluting your system even if you do it the other way. Nix (and its younger cousin GNU Guix) are tools that already have changed the world into its post-Docker form (for most people most of the time), but the world just doesn’t know it yet.

The Journey to Trilium

So in this quest to find a SimpleNote replacement for mobile idea capture, all the Obsidian/Notion envy that had been building up over the months (for I had tried and discarded both) came bubbling to the surface. I found Foam, I found Logseq, Roam, Standard Note, FSNotes, I found tons of Wiki’s. I mean, these things are endless! And you can’t go all-in to try them all. So I made my criteria as self-hosted, a trivial install under NixOS, a usable experience from the mobile/desktop Web/Client experience, an AIP and fast synchronization.

You know, it’s really surprising how few made the cut. Things that are self-hosted but also intended to be accessible from other devices on your local area network, and potentially even the Internet at large (if you want to go that route), need more than just a single entry in NixOS. Inevitably they need at least a few more lines to get them running as a service, setting a port, dealing with security, etc. And so a trivial install under NixOS meant that 1-line to get it installed, and then it not being a convoluted mess to get it actually hosting the notes app to other devices.

Discovering Trilium’s Features

And Trilium fit the bill precisely. And oh, was it feature-rich! At first this scared me and almost disqualified it as “not as simple” as SimpleNote. All these note organization things are philosophically laden, written by people with strong thoughts abut how to organize. That’s why things like Obsidian really take off. They scratch an itch just a little better than the competitors in a way that just hits right. They resonate with their audience. And Trilium did not resonate with me at all… until I saw the mermaid diagrams.

I was like “hmmm, where there’s Mermaid rendering, there must be Markdown rendering too, and so I queried in Plexity as I constantly do, copied the Markdown, went over to Trilium and found a little “paste markdown from clipboard” icon specifically for this use case, and WOW! There was the formatted markdown in all its glory, minus only the color-coding of the programming syntax, which is understandable and forgivable. But here I had not only something I didn’t know I wanted in a note-taking app, but it’s likely to break me of my InstaPaper addiction for article-collecting, in addition to SimpleNote.

Web Clipping and Knowledge Management

When coupled with a Chrome plugin like “MarkDownload - Markdown Web Clipper” that lets you copy webpages as markdown, you paste them into notes preserving all that lovely markdown, and you’re collecting well formatted articles for local reading. If the article goes away, you’ve still got it. You can organize it like a knowledgebase. It works offline. And when the time comes for you to train a local AI model or build a RAG search feature of your personal documents, you’ve got all of that as training material and assets, copyright issues aside. But I did not expect that from what I was intending to be a lightweight replacement to SimpleNote. I mean, I even looked at hosting Etherpad, and how different of an experience that would have been.

Trilium’s Mobile and Desktop Experience

I don’t think I’m going to turn this into a review of Trilim, suffice to say that the surprises kept rolling in, and I have a lot to learn from it. After the server-version, which let it run on a web address in the browser immediately, I installed the desktop version, which is an Electron app. From Safari on mobile, you can go to that same URL and use the Share link to “Add to Home Screen” for much the same native app look and feel (same trick as Electron) while still effectively being a web page at its core, just stripping away all the browser distractions.

Network Graphs and Future Directions

And I guess the final last thing that I need to mention is that the very cool network graph that links all your notes together visually in a bouncy force graph that Obsidian touts as such a major feature is built into Trilium like its no big. And bouncy hierarchical force graphs to expose relationships between things are… uh, shall we say relative to my field of SEO.

I have a lot to learn from Trilium and certainly will be picking it apart to see how to use d3-force.

I have fully sworn off JavaScript… except when I haven’t. Ugh! You don’t walk away from power-tools, especially when they’re free and open source and as cool as the d3 link force

I think I have some ideas about what to write about next.