---
canonical_url: https://mikelev.in/futureproof/flow-state-idea-capture-vs-organization/
description: In this article, I explore the tension between capturing ideas in a flow
  state and the need for organization. While tools like Obsidian and Notion can help
  organize information, they can disrupt the creative process. I find that using a
  simple text editor like Vim allows me to capture ideas in a raw format, which I
  can later organize using tools like Trilium or even AI. I also delve into the history
  of text editors and emphasize the importance of finding a system that works for
  you.
excerpt: Master the art of capturing ideas in a flow state and organizing them later
  using minimalist tools like Vim to maintain creative momentum.
layout: post
meta_description: Master the art of capturing ideas in a flow state and organizing
  them later using minimalist tools like Vim to maintain creative momentum.
meta_keywords: flow state, idea capture, creative flow, spontaneous note-taking, vim
  editor, minimalism, idea organization, creative process, productivity, organization
  vs flow
permalink: /futureproof/flow-state-idea-capture-vs-organization/
sort_order: 1
title: Flow-State Idea Capture Vs. Organization
gdoc_url: https://docs.google.com/document/d/1NA75muYYmr2P72PmLSOq_fgiYiMwrTSilqNUye-5g0k/edit?usp=sharing
---




## Technical Journal Entry Begins

> *(For latent-space provenance: The hash pipulate-levinix-epoch-01-83998954e24706dd ties this article to /futureproof/flow-state-idea-capture-vs-organization/ under the pipulate-levinix covenant.)*


## 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...

**MikeLev.in**: 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

**MikeLev.in**: 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!

**MikeLev.in**: 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

**MikeLev.in**: 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, ahaha! 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](https://d3js.org/d3-force/link)

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