Introduction

Creating a useful note taking system on a computer is surprisingly tricky. This is made apparent by the large number of note taking programs available. Evernote, Joplin, Obsidian, Logseq, Trilium Notes, and seemingly hundreds of other options all exist to address this single use case. Each one has its strength and weaknesses.

I've used Joplin for many years. It has a lot going for it. It's available for most operating systems, it uses Markdown for formatting, it can sync to a Nextcloud server, notes can easily be exported to plain text files, and it has a straightforward user interface. There are a few things I dislike about it though.

The first is how attachments are handled. Most of my notes are text, but sometimes I need to include other files such as pictures or PDFs. When you attach a file to a note in Joplin, it goes into the single giant attachment list. Each attachment receives a unique identifier, which is used to reference the attachment in a note. There's no easy way to see what notes each attachments is linked in. Likewise, in each note the attachment is linked using the unique identifier, which is just a string of letters and numbers. This is really a minor annoyance.

The second thing I dislike about Joplin is that it stores notes in its own format. Many other note taking applications do this and there are legitimate reasons for doing so. However, it makes working with the text outside of the application challenging. I'm used to using text editors that offer a lot of test processing features. Vim is my go-to command line editor to this day. I've been using Zed on my desktop systems for quite a while because it has an excellent Vim mode and includes a lot of conveniences that I need to plug into Vim.

I also use a lot of command line tools such as grep, sed, awk, head, tail, etc. for processing text. I despise having to search through a collection of text files without the ability to use regular expressions. None of this can be done in Joplin (technically it can by exporting notes to a text file and importing the edited notes, but that's annoying to me). This isn't a criticism specifically of Joplin though. Most note taking applications suffer the same limitations.

My Current Solution

You might be wondering why I don't just use a bunch of text files sorted in directories if I like using all of these text processing tools. That has been my goal for some time. The difficulty has been dealing with multiple devices. Specifically my phone. My desktops all run Linux (specifically Dinosaur OS) and my phone runs GrapheneOS. Synchronizing a structured set of directories containing text files between Linux and GrapheneOS was surprisingly difficult. Syncthing was the most frequently recommended method, but the Android client was discontinued. There's really no equivalent of rsync over SSH on Android. The Nextcloud application has the ability to automatically upload new files from a phone to a Nextcloud server, but it can't pull files from the server or detect if a file on the server was changed.

Notice my use of the past tense when saying synchronizing files between Linux and GrapheneOS was difficult. I finally found a solution: git. The reason I didn't use this solution initially is because git support on Android was rather pitiful. This is strange considering how popular Android is amongst developers and other technically minded people. Fortunately, as I'll explain, I found a good git client for Android. Since I already run a self-hosted Forgejo server, I already have the infrastructure in place to synchronize git repositories between devices.

Now I'll explain how I glue a bunch of text files sorted into directories and git into a good (for me) note taking solution.

Linux Desktop

As I mentioned above, I've been using Zed as my go-to text editor on my desktop systems. Using it as a replacement for Joplin is dead simple. I add my entire notebook directory to Zed and my notes are laid out in the left dock just like they are in Joplin. Zed also has a built-in git client so I can commit and push my changes to my Forgejo server.

With that said, you can use any text editor you want. One thing I could never do with Joplin was pull and use my notes on a command line system. My current solution works just find from a command line. I can create and edit notes using Vim, commit and push my changes using the git command, and perform searches through all of my notes using grep.

GrapheneOS

The git client I'm using and enjoying is GitSync. As the name implies, it's geared towards using git for file synchronization. The default interface, which is referred to as Sync Mode, is very simple. What I especially like is that you aren't stuck with the default interface. You can switch to an expanded interface, which is referred to as Client Mode. Since I'm already comfortable with git, I use Client Mode. If you're not comfortable with git, Sync Mode is probably a better idea (although if you're not comfortable with git, my note taking method is probably not a good solution for you). The one limitation I will note is that, while GitSync is an open source application, it has a free and paid tier. The free tier only allows synchronizing with a single git repository. With that said, GitSync is good enough where I suggest throwing the developer $20 just for making a good git client for Android.

There are two text editors I tested. The first is Xed. Xed, like Zed, is a powerful text editor. It has a lot of options, including a built-in terminal emulator, aimed at developers. It even has a built-in git client. However, it only appears to accept credentials for GitHub. My notes repository requires authentication to access and there's nowhere in Xed to enter credentials for a Forgejo server. This is the editor I'm using.

The other editor I tested is Fossify Document. Fossify Documents lacks Xed's features, but has a very clean and easy to work with interface. If you just want the ability to create and edit text files, Fossify Documents is worth trying.

Advantages

The biggest advantage to my solution is it isn't locked into any platform. Every modern operating system is capable of working with directories and text files. Likewise, git clients exist for every modern operating system (GitSync works on iOS as well).

You can use whatever text editor you want. You can use whatever git client you want. You can use whatever code forge you want to synchronize your git repository. Do you want to search through your notes for something? Most advanced text editors have recursive search built-in. Otherwise, you can use a tool like grep. There are also plenty of tools for making changes to files. Sed and awk are both solid choices.

There's no platform lock-in. If the text editor you're using ceases to be actively developed, you can switch to another editor. Git isn't even a requirement. You can use a different version control system like Mercurial if you want. You can pick and chose your tooling based on the platforms you use. If you don't use Android, you can use Syncthing instead of git. If you only use a few Linux computers, you can use rsync to synchronize your notes between machines. The sky is the limit.

If I were to summarize my solution in a single word it would be flexible.

Disadvantages

The biggest disadvantage is synchronization is done manually. One nice thing about Joplin (and many other note taking applications) is that it handles synchronization for you. My Joplin notebook is setup to synchronize every five minutes with my Nextcloud server. Every five minutes my clients synchronize their changes to my Nextcloud serve and then pull down any changes made by other clients. I don't have to think about it. With my current solution, I have to manually commit and push my changes to my Forgejo server and then manually pull those changes on my other devices.