After initially starting to use Emacs back in high school merely for programming, I naturally began to use it for other tasks such as document preparation and note-taking. This introduced me to the surprisingly large overlap between Emacs users and people generally interested in “productivity” workflows.

This is not all that surprising however. It is partly due to how good Emacs’ ecosystem has become for these specific types of tasks (things like Agenda, org-roam, denote, and howm — even org-mode itself — were all created for these uses) but on a more fundamental level Emacs allows you to work with any form of text not just efficiently, but also in a way that is entirely customised to your own preferences and comforts.

As I became more proficient in Emacs and read more perspectives on how other people organised their notes, I tried to evaluate my views on note-taking that I had held before. You may have an idea of what it means to be productive, but this post is instead about another form of productivity, one that does not have to rely on the powers of gnu Emacs, but instead of the agent itself, the author.

Productivity qua measurement is the amount of goods (or products) that are produced per unit of time. For this reason it has become common for people to link improvements in productivity to the aspect of time specifically. But productivity is even more innately linked to the product itself, and it is this aspect that I would like to focus on here.

What I choose to call productive note-taking is fundamentally anchored in not the rate at which one produces notes, or even the quality of the notes, but instead in mental model that one uses when producing them. Advocates for Zettelkästen-based systems argue that notes should form a mental (or sometimes digitally represented) web of thoughts that links each “note” with its equals. What I propose here is instead a form of notes that are different in that they are meant to develop not some separate bank of data, but to develop the cognitive abilities of the author, while still creating a tangible work.

The word revolution, while evoking signs of violent rebellion, has its roots in the term for turning. It of course still means this (as in the phrase “revolutions per minute”, rpm) and it is in this sense that I mean revolutionary notes. I have used it in this sense before, and am quite fond of this mixture of images — of a dramatic change that returns to some earlier state, albeit with new experiences and ideas.

I have taken notes almost daily during my many years in the education system, but have undertaken a more critical view of my use of notes during the first half of this decade. Almost a year ago I published a piece of writing on my evolving experiments with a Zettelkasten system, implemented using org-roam. Writing that piece I subconsciously knew that as soon as it was published I would move away from the implementation I was writing about into a more holistic direction, although I was unsure of what shape that would take. After finishing a course in Contemporary Warfare I feel like I finally have what I can coherently describe as a solution — to the extent that it exists as a vestige of my mind.

Productive note-taking is productive in the ways that it emphasises and highlights the importance of the end product. It is note-taking for the aim of production of a given work, not for the aid of remembrance or recollection. While these latter elements may play a part in the production of the work, they are not in and of themselves goals.

When I was still studying mathematics, I noticed a sharp decrease in my understanding when I redoubled my efforts to produce more comprehensive notes to help me study. Where I had before been able to keep pace with the best of my peers, I had now fallen behind to the middle of the pack. This seemed paradoxical to me — how can studying harder result in a worse performance? The answer seems obvious now, I was prioritising the production of more and more notes over my understanding of the subject material. It is this sort of activity that productive note-taking seeks to avoid.

Sara Imari Walker writes in noema about how ai systems fail to fulfill the role of the scientist because science is a “fundamentally intersubjective” act — where theories (as symbolic representations) are argued out and decided upon in the process of free discourse. When writing, communicating, and debating we are constantly refining, creating, and recreating our ideas, performing science as a societal dialogue. This intersubjective discussion is what things like journaling try and emulate — and it is also what I propose notes can do.

How does one create notes as products? This is a difficult question to answer generally, and will depend on a variety of factors such as the subject material, learning method, audience, and personal preferences. What all techniques should share in common is a centrality in all activity being motivated by the creation of some final work.

The work that spawned the concrete formula of a productive workflow is my collection of notes on contemporary warfare. The exam for that course was structured as an essay about any one of a selection of broad topics, and in place of literature we were allowed 30 pages (15 sheets) of notes, written either by hand, printed, or a combination of the two, covering whatever information we wanted¹.

This meant that my studies did not just consist of me reading Clausewitz all day trying to memorise every word or phrase — the goal was for me to get a good enough understanding of Clausewitz, Mahan, and many other thinkers so that I could condense their theories into this one document. Doing this required a complete understanding of the topics.

Proponents of Zettelkästen often emphasises the ability for their constructs to function as “second brains” — perfectly recording and remembering information that our feeble flesh brains so easily forgets. But as a philosopher² my goal is not to create as much recorded information as possible, it is for me as an individual to understand and master the world around me. Having information written down is useless if I do not remember it, and if I remember it there is no point in writing it down. Seneca writes

We should see to it that whatever we have absorbed should not be allowed to remain unchanged, or it will be no part of us. We must digest it: otherwise it will merely enter the memory and not the reasoning power.

Productive notes are then not principally meant for consumption, but instead their initial omission prompts their creation. The author is required to go out into the world and obtain the relevant knowledge to produce the work — either through reading the scraps of knowledge left behind by those who came before³, or through creating new knowledge by living as an agent in the world.

Performing this approach does not require any specific hardware or software since it emphasises the primacy of the authors mind over the — ironically — product. You can do this with a pen and paper, text files (written in whatever markup you want), a wysiwyg editor like Microsoft’s Word or even using Zettelkasten. Writing short notes is also not “forbidden” as long as they are meant to help record the information required for implementing the final product.

There are no constraints on the shape of the end product either. It may be in the form of a text document (written in whatever style you would like), an email, an interpretive dance, or a physical structure. If you want a more concrete example here are my notes on contemporary warfare in pdf form⁴. They are written as a single .org-file with a header for each lecture/topic, and with a few quotes from selected other works.

ja Westenberg wrote about their experience with building a “second brain”, and the anxiety that comes with an ever growing amount of information that you have to work through and make use of in some way:

The more my system grew, the more I deferred the work of thought to some future self who would sort, tag, distill, and extract the gold.

That self never arrived.

Steve Krouse accuractely points out that vibe code is legacy code — code that no-one understands. In the same way notes or written works that are merely vibed (either written with llms, copied from a primary source, or not mentally processed in another way) turn into legacy information that has to be painfully worked through in order to actually master the information contained within (to extract the gold, to use Westenberg’s phrasing).

The point of productive notes is to make this a unnecessary. I could easily delete my whole ~/Documents/Notes directory today and continue on with my life, without any feelings of remorse or anxiety, because the truly important information is that which I already remember. If I forget something I simply have to search for it again, and in the process will likely discover new interesting things about the universe through my lived experience.

There is however a reason that I have not deleted my notes directory — there is genuine value in recorded information — but one has to be careful to avoid falling into intellectual atrophy. Being discomforted by having to retread old paths is a conscious method for intellectual growth. If recording facts was all that was required then one’s notes should merely consist of written down conversations with llms.

If this approach seems like something trivial to you — great! You might already be doing what I have merely described. It is once again this that I mean by the revolutionary quality of this technique; it is a return to the original state and intention of note-taking.

If you disagree with me vehemently, have some constructive criticism, or have some examples of you doing this or anything similar, feel free to email me. ❦

Emacs has a tendency to try and absorb all user-facing interactions I have with a computer. Some people seem able to separate “Emacs stuff” — like programming or using org-mode for note taking — but Emacs’ extendability makes me want to use it for everything. For a long time I have only really needed four different tools to do any kind of work at a computer:

1. gnu Emacs (with my personal config).
2. Tailscale to connect to my other machines.
3. Syncthing so that I have local access to my files¹.
4. A web browser (usually Firefox).

Quickly getting these four things up and running is usually my first priority when setting up a new machine, and they require different amounts of work. Critically Firefox requires a gui environment in order to run, but it’s really quite unnecessary to get a desktop environment or tiling window manager up and running — and dealing with their conflicting keybinds — when all I’m going to be doing is working in Emacs perhaps 80% of the time, finding information or reading docs in Firefox 15% of the time, and using a stray terminal the remaining 5% (something I can easily replace with one of Emacs’ many terminal and shell solutions). This is why I like using exwm². Rather than using Emacs’ window manager capabilities to manage all your X windows it allows you to stay continually within Emacs and just treat any stray non-Emacs gui programs within the same system. The solution then seems to try and subsume web browsing into my preëxisting workflow. There are many solutions to this, but I prefer ones that work with text as the primary medium as that is what Emacs is best oriented to work with.

eww is probably the most well-known of Emacs’ web browsing solutions, chiefly because it comes included with it. It is also the one I have the most experience with. I first came across eww as a consequence of reading about all of the crazy features included in Emacs by default like Tetris and Gnus. This isn’t very surprising; web browsers are some of the largest ubiquitous user-facing applications, so the fact that Emacs ships with one as a tangential feature is very surprising. However, these visions of browsing the web are often quickly crushed when one uses eww for the first time. It does not load any css, so websites do not look like one is accustomed to, and a lot of javascript functionality is non-functional.

I expect this experience — or at least something like it — to be somewhat universal amongst those who have even tried using eww. The modern web is built around these technologies, and going without them might seem almost impossible. But there is a place for eww in a modern workflow. The strength of Emacs is its power for working with text, and most media I interact with in a web browser is text. Emacs then is really the perfect environment for this. Reading and rewriting the content of web pages side-by-side using the same key-chords and user-interface allows for minimal context friction. But there are serious downsides, primarily ugly formatted headers and images. Most of the time eww can figure out the main readable content using the eww-readable function, bound to R by default. It’s meant to strip out long “navigation menus and the like”. In my experience it is either hit or miss. For some web pages like wikipedia it seems to work well (but only for some pages), but for others like github it just strips out the entire page. Thankfully it is bound to a convenient key and its easy to switch between the two views quickly. Images are probably one of the first things that stops people from using eww, with large ones causing the site to jump around as they cover the whole screen and then disappear. I solved this using ultra-scroll, which provides scrolling smoother than you could ever imagine in Emacs. It also allows you to scroll intuitively over images, rendering them as you would expect in a traditional browser like Firefox. With a slow network connection eww can have some problems with blocking, but this can be remedied by setting eww-retrieve-command:

(setq eww-retrieve-command
      '("chromium" "--headless" "--dump-dom"))

eww is written by Lars Ingebrigtsen of gnus fame. It uses the shr (simple html Renderer) program written in elisp to render html. He originally wrote shr to read elfeed entries in Emacs and eww is merely the addition of browsing (or wowsing) capability built on top of it. shr’s elisp nature is why it can sometimes struggle with complicated site layouts, but in my experience it is usually fast enough, especially with native compilation.

Generally eww can be surprisingly powerful, but most of its power (like Emacs itself) comes from its tight integration with other tooling and extensibility with elisp, rather than any amazing workflow it has built for you in advance. There is very little to learn, but a lot to master.

w3m can some sense be seen as the “hardcore” version of text-based web browsing in Emacs. w3m relies on the eponymous tui program to render web pages in a way similar to Lynx, allegedly the world’s oldest continually-maintained web browser. w3m even comes with lynx bindings by default, although you can also change them to the included “info-like” ones. It allows for tabs, bookmarks, and other features one would expect in a modern browser. It also relies on interpreting the raw html to format the page, rather than rendering css. Like eww it also does not support javascript. Like I alluded to earlier, this is both a blessing and a curse, and reading just straight text can be very nice, both from a therapeutic minimalist way and a way to minimize context-switching. It is also nice and async by default, since it uses an external binary to fetch websites, not that it takes very long to load to begin with since it’s not running any heavy javascript. One nice difference between w3m and eww is also that the arrow keys navigate to the next link in the page by default, and the text in the buffer will resize itself whenever the buffer is resized³, something that is very handy if you’re using a package like golden-ratio that resizes windows depending on focus.

While I prefer text-based browsers that fit more seamlessly into the rest of Emacs, there are other solutions for more traditional browser experiences.

I have been using gnu Emacs for about three years now. I initially began using it after completing a semester of introductory programming classes exclusively in gnu Nano, with a series of shell scripts to compile and run C# code, and to set up a trio of terminals; one for code editing, one for compilation, and one to actually run the cli program I was writing. I had practically created my own little system for terminal multiplexing. This might sound like hell, and in hindsight it was. I was not even aware of some of the abilities of nano to perform syntax highlighting, display line numbers, indent lines et cetera. I merely needed something quickly to write text in, and was horrified at my classmates who had to sit idly and wait for visual studio to start or restart after crashing, it did not help that visual studio was not even available in platform of my choice. In the beginning I only needed to write short programs, simple loops, input and output and the like, and so the simplicity of nano was not in any way a burden — in some ways it was even a boon due to its quick startup time and lack of clunky ui. But eventually I found it annoying having to create and resize my layout of terminals and writing long commands to get Microsoft’s Windows-centric tooling to compile on Linux became a chore. So I created little scripts to optimize my workflow. Nothing incredibly complex mind you, just little fixes here and there. When what is called “fall break” in Sweden came around I decided to ditch Nano entirely. I had friends who used Vim, but being a staunch hipster I decided I couldn’t copy them, at least not without trying the alternatives.

And so I started out with gnu Emacs. The approach of an environment I could extend in-situ, rather than having to deal with a multitude of different tools obviously appealed to me greatly, having done so earlier using shell scripts. I completed my assignments much faster than I was expected to, and used the extra time in class to read An Introduction to Programming in Emacs Lisp from within Emacs, making me more and more inclined to extend and shape Emacs to my own needs. Eventually I found out about org-mode and started to use it for very simple notes, quickly jotting down grocery list and project outlines. The big threshold came when I discovered the in-built functionality for \(\LaTeX\) exports. I had some early encounters with latex, but most of my knowledge was limited to what it was conceptually and how to write \frac{}{}. However, the default article class that is used when exporting from org-mode looks very nice, at least compared to what I was writing in LibreOffice or Google Docs. It is of course possible to get a similar quality in output from a wysiwyg¹ editor, but the amount of time you’d have to put in to do so is much larger than simply writing the text in org-mode and pressing C-c C-e l p. This of course does not have any impact on the quality of output, but as a fan of typography I like to think that a nicely formatted document enhances ones Aristotelian ethos, in that your credibility as a writer is improved in the eyes of the reader. Emacs therefore became relevant in not just my programming classes and microcomputer classes, but also all classes that involved some sort of essay or technical writing — Swedish, English, religious studies, history, engineering, and management. But there were two main subject that took up a considerable portion of my time where I had to put my cohesive Emacs workflow aside and resort to traditional techniques: physics and mathematics.

For taking notes I started out with a simple notes.org file, separating subject and topics organically with headers. I would recommend other to do the same. Initially, simply writing things down is the goal, and any optimisations will likely result in a net loss. I was inspired by Gilles Castel’s next-to famous series of blog posts on his note taking in LaTeX and vim, particularly his emphasis on “no delay [being] acceptable”. Of course, there are significant deviations in mine and Castel’s approaches and, to be perfectly honest, I think his notes are of a far superior quality. The primary difference is in medium; while the mathematics are written in latex, I prefer to write prose in the much lighter syntax of org mode or markdown, no \emph for me. Instead, I use org-latex-preview and org-fragtog to display latex inline and use the org documents themselves as notes instead of exporting them to pdf. Here is an example of a quick step-by-step way to solve first order differential equations using the integrating factor:

While Karthink has shown that you absolutely do not need to rely on writing snippets as Castel does, I still take that approach. Karthink relies heavily on auctex, an amazing suite for writing latex in Emacs, but most auctex functionality can not be used directly in org-mode. cdlatex, by the same author as org-mode, is however very useful through the org-cdlatex-mode minor mode. It allows for auto-completion of commonly written things like \(^{\text{super}}\) / \(_{\text{sub}} \text{-scripts}\) and Greek letters. It also creates a “just press tab whenever you want to continue writing” workflow that will move point in or out of delimiters and complete symbols. This combined with a liberal set of custom expanding templates using yasnippet creates a fast and coherent system since yasnippet also uses TAB as a key by default, meaning that you can spam it throughout writing, only thinking about the math conceptually as you’re listening to the lecturer.

But Emacs is not limited to writing mathematics merely in a documentary fashion, but also in a practical one. While theoretical mathematics operate on the syntax of math itself (algebraically), physics is often times interested in the actual values of the operations. For this I often quickly wrote mathematics in polish notation directly, also known as Emacs lisp. I find algebra difficult in polish notation, and so I usually do it in latex first, only performing the last numerical calculation in lisp.

This is what I would call the “killer app” of org-mode compared to other note taking applications like obsidian or pure \(\TeX\) files. Being able to instantly tap into a programming language is really powerful, but it also feels very powerful, even when doing trivial things. Quickly being able to jot down numerical calculations (and having them written down for future reference) is quite useful. While I am sure one can write notes in Jupyter notebooks and other computational documents I have yet to hear of someone do this². Emacs’ configurability means that one can easily adapt it to one’s own needs rather than either writing your own incomplete tooling or learning someone else’s workflow.

After high school I have taken a break from the hard sciences and studied a few different subjects at Stockholm University and the Swedish Defence University. What strikes me as fundamentally different is that while mathematics builds on itself very clearly, where you directly use earlier knowledge to explore new topics, the social realm is a lot more “flat”. One can jump directly into Foucault’s postmodernism or Hegel’s Phenomenology and, while of course missing valuable context, still enjoy a degree of understanding. Comparatively it is quite difficult to get any sort of a grasp for quantum chromodynamics without firm knowledge of the structure of the atom. I also felt that studying depended much more on obtaining a breadth of ideas and perspectives rather than sitting down and mastering whatever new topic the lecture had covered. This then called for a radically different approach.

I ditched my former monolithic “one large file” approach and instead, somewhat reluctantly I admit, began using Org roam. I was critical toward the preaching I observed being done by users of various Zettelkästen systems and felt like the idea of a “second brain” encompassing all your knowledge were useless. Having used the system for almost a year now I still feel the same way. It is quite useful to be able to link ideas, since broad concepts and actors often show up in multiple areas³.

I also took inspiration from Gregory Stein to create an org-mode bibliography that combines notes of books and articles with their respective bibtex entries. Here I am back to the monolithic file approach, with each book or article read merely separated into different broad categories⁴. I have quite a backlog of saved .pdf files that I would like to convert to this new bibliography, but I do not have the time to do it all manually. To start I instead just asked an llm to convert my hand-written citations for coursework into bibtex entries and sorted them into the file. I will let it grow organically from there.

Academia is in the end a forum for the exchange of new ideas, and the most efficient mode for the spread of ideas is text. While we may see some change in the structure of academic writing, particularly for those less experienced, as a result of large-scale llm usage I doubt that text will be dethroned as the primary mode of communication for human society, but this is really a subject too deep to cover in a text about using Emacs as a student. For the time being writing reports and essays is still relevant to one’s daily life. I of course do this in org-mode, simply adding some latex headers to the document when I am done:

#+title: The Meiji Restoration and Modernisation of Japan
#+subtitle: IR1.1 Seminar 1 Preparatory Assignment
#+author: Joar von Arndt
#+options: toc:nil
#+latex_header: \usepackage[a4paper, top=2in, bottom=2in, left=1.7in, right=1.7in]{geometry}
#+latex_header: \usepackage[activate={true,nocompatibility},final,tracking=true,kerning=true,spacing=true,factor=1100,stretch=10,shrink=10]{microtype}
#+latex_header: \usepackage[T1]{fontenc}
#+latex_header: \usepackage{lmodern}

For longer assignments I usually use a two-column layout. I tweak the values for the margins when I am done writing and ready to submit or print so that the text nicely fits the page, since I think it looks more “complete” and planned out that way. Otherwise I just write plainly in org-mode, using footnotes for citations.

Emacs is a tremendously useful tool, and I hope that this either serves as a motivation for beginning to use Emacs (showing of what can be done in it) or to inspire someone else to take inspiration in their own daily activities. I was prompted to writing this by Daniel Pinkston’s talk at EmacsConf 2024, and saw an earlier version of myself in him. I particularly want to emphasize that one approach does not fit all, not even when it comes to personal preference. Some lifestyles/subjects require different techniques, and so you should both experiment and iterate continuously to see what works for you. This is in-line with the Emacs philosophy of complete and instant extensibility, and so I therefore could not imagine a better platform to be writing or taking notes in. ❦

This site exists in the overlap between a landing page, a traditional blog, a hypomnemata, and what is called a “digital garden”. I originally used the domain merely to host services and small programs over the open internet, and to have a place to point to and say “this is where you can find me online”. I started writing things because I found that certain topics kept coming up in discussion with the people around me, and I wanted to summarise my thoughts on them. A website was the perfect place for that.

I write many pieces concurrently, and publish them either when I feel they are finished or when my motivation has drained and I feel like I need to “just get it out there”. In some cases I also get a large boost of energy and write a post in even just a day or two, although I often try and stop myself from publishing immediately in order to let my thoughts simmer for a bit.

I then expand on topics if I come up with new perspectives or need to respond do a new development. In this way posts exist in a space between being mere ephemeral blog posts that were written at a given time and a continually rewritten and updated page. I try to avoid changing the main theses of a post after initial publication — even if I have come to disagree with myself over time — and so they still reflect the version of myself when they were first written.

The website is written in gnu Emacs and in org mode, because I find the markup to be intuitive, natural, and easy.¹

The primary font used is Sabon. Code uses the Greybeard font. The headers are all typeset in the beautiful DaVinci by the nyc creative bureau Virgile Flores. For 中文 (and other cjk languages) I use Kai Ti since the default Noto font installed on many devices clashed quite a lot with the thin serif fonts I otherwise use.

I jump quite often between fonts, especially for the serif font for body text. In this way having a website is quite useful; it allows me to experiment widely with design in an actual production environment.

I generally took a lot of inspiration from others using the same tooling as me, as well as from Gwern, Maggie Appleton and various other blogs and homepages I have read over the years. The colour scheme is a slightly adapted version of Protesilaos Stavrou’s modus themes (for the light theme) and the paradise theme (for the dark). I find them visually pleasing, and the Modus theme is very accessible to those with impaired vision. I have used them in Emacs for a long time, and so they fit nicely on my desktop when looking at my site.

The one-rule css implementation of the drop caps is taken from Michał Sapka, while the font files were downloaded from Gwern using a quick curl-script I had an llm write.² The font is “Baroque Initials”, more information here. The indented paragraphs were inspired by Miró Allard.

The little arrows following external links (of which there have been quite a lot in this section) are from Alex Wennerberg, whose simple design I find admirable. Using email as a comment system was taken from Marcel Wichmann.

The blog is generated using Bastian Bechtold’s org-static-blog. I have an elisp file that runs the necessary configuration code and acts like a declarative configuration for the deployment of the static site. It looks like this:

(setq org-static-blog-publish-title "Joar von Arndt")
(setq org-static-blog-publish-url "https://joarvarndt.se/")
(setq org-static-blog-publish-directory "~/Documents/blog")
(setq org-static-blog-posts-directory "~/Documents/blog/posts/")
(setq org-static-blog-drafts-directory "~/Documents/blog/drafts/")
(setq org-static-blog-enable-tags t)
(setq org-static-blog-enable-og-tags t)
(setq org-static-blog-image "https://joarvarndt.se/vonArndtCrestWhite.png")
(setq org-static-blog-use-preview t)
(setq org-static-blog-no-comments-tag "nocomment")
(setq org-static-blog-enable-tag-rss t)
(setq org-static-blog-index-length 6)
(setq org-static-blog-preview-link-p t)
(setq org-static-blog-preview-ellipsis "<span class=\"ellipsis\">Continue Reading</span>")

These are all simple configuration values that are unique to org-static-blog, and where most of the values are themselves unique to this blog specifically.

(setq org-export-with-toc t)
(setq org-export-with-broken-links t)
(setq org-export-with-smart-quotes t)
(setq org-export-with-section-numbers nil)
(setq org-image-actual-width nil)

;; For syntax highlighting of code (Like this).
(setq org-src-fontify-natively t)
(setq org-html-htmlize-output-type 'css)
(setq org-src-preserve-indentation t)

org-static-blog uses org-mode’s built-in html export functionality for much of the “dirty work”, and these variables are used for all org-mode exports. The latter part allows Emacs to transform its own syntax highlighting into css classes that I can then highlight with css variables depending on dark/light theme. This is all done at the rendering stage, meaning things like highlight.js are unnecessary. Without setting these variables Emacs will hard-code the current Emacs theme colours into the html.

(setq org-static-blog-display-git-date t)
(setq org-static-blog-title-link nil)

(setq org-static-blog-hidden-directory "~/Documents/blog/hidden/")

These are variables used in my own custom fork of org-static-blog. This toggles the display of the “last edited” date at the top of the post page, derived from when the .org-file was last changed. All the original org-mode files are uploaded to the website, and can be accessed by navigating to “https://joarvarndt.se/posts/postname.org”.

By default org-static-blog renders the post title of each page as a link pointing to itself. I found this quite distracting as it means displaying responsive changes whenever the title is hovered over. This variable thus disables that functionality.

The hidden directory acts as a sort of middle-ground between drafts and posts; I have the drafts directory marked in the .gitignore file and can therefore not use git to track changes made to files in that directory, but I do not want pages like subscribe, about, or the link page to show up in the archive page as a proper “post”. For this I use the hidden directory.

(setq org-static-blog-preview-start "<p class=\"dcap\">")

I have written a function that applies the dcap class to the first normal paragraph in a post, but adding such a class means that the default “<p>” value will match the second paragraph instead of the first. This change thus needs to be made.

(setq org-static-blog-page-header
      "<meta name=\"Joar von Arndt\" content=\"Joar von Arndt\">
       <meta name=\"referrer\" content=\"no-referrer\">
       <meta name=\"viewport\" content=\"initial-scale=1,width=device-width,minimum-scale=1\">
       <link href=\"static/style.css\" rel=\"stylesheet\" type=\"text/css\" />
       <link rel=\"icon\" href=\"static/favicon.ico\">
       <link rel=\"me\" href=\"https://github.com/JanJoar\" />
       <link rel=\"me\" href=\"https://gravatar.com/speedilyrunaway0201f99245\" />
       <link rel=\"pgpkey\" href=\"/key.pub\">
       <link rel=\"webmention\" href=\"https://webmention.io/joarvarndt.se/webmention\" />
       <script src=\"static/sidenotes.js\" defer></script>
       <script src=\"static/comments.js\" defer></script>
       <link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/katex@0.16.33/dist/katex.min.css\" integrity=\"sha384-fgYS3VC1089n2J3rVcEbXDHlnDLQ9B2Y1hvpQ720q1NvxCduQqT4JoGc4u2QCnzE\" crossorigin=\"anonymous\">
       <script defer src=\"https://cdn.jsdelivr.net/npm/katex@0.16.33/dist/katex.min.js\" integrity=\"sha384-YPHNAPyrxGS8BNnA7Q4ommqra8WQPEjooVSLzFgwgs8OXJBvadbyvx4QpfiFurGr\" crossorigin=\"anonymous\"></script>
       <script defer src=\"https://cdn.jsdelivr.net/npm/katex@0.16.33/dist/contrib/auto-render.min.js\" integrity=\"sha384-JKXHIJf8PKPyDFptuKZoUyMRQJAmQKj4B4xyOca62ebJhciMYGiDdq/9twUUWyZH\" crossorigin=\"anonymous\"
       onload=\"renderMathInElement(document.body);\"></script>")

(setq org-static-blog-post-comments
      "<div class=\"comment-by-email\">
         <form class=\"comment-by-email-form\">
           <textarea id=\"comment-by-email-textarea\"
             placeholder=\"Write a comment\"></textarea>
           <button type=\"submit\">Send</button>
         </form>
       </div>")

This is quite self-explanatory, it formats the header for each page so that the correct css, javascript, favicons et cetera are loaded. While the website does make use of javascript I have as an utmost priority that it should be accessible and readable without it. There are really only three elements that require javascript:

1. Comments, who quite simply creates a mailto: -link that is filled in with the appropriate information (including recipient, subject header, and content inserted on the website). All of this can of course be done manually by emailing me the old-fashioned way.
2. Client-side \(\LaTeX\) rendering using \(\KaTeX\). This should be possible to render server-side and therefore remove, but I have yet to build a way to do so using my ssg. A project for the future.
3. Sidenotes. I cover this further down.

(setq org-static-blog-page-preamble "<div class=\"header\" role=\"banner\">
                                     <a href=\"https://joarvarndt.se/\" class=\"home-link\"><img id=\"themeImageHeader\" src=\"vonArndtCrestBlack.png\" class=\"header-img\" alt=\"Crest\" width=\"50\"></a></div>")

(setq org-static-blog-page-postamble
      "<div id=\"postamble\" class=\"status\"><div class=\"footer\" role=\"contentinfo\">
       <div class=\"footer-upper\">
       <footer-img><img loading=\"lazy\" class=\"footer-img\" id=\"themeImageFooter\" src=\"Ship-5.svg\" alt=\"Set sail on the sea of knowledge\"></footer-img>
       <copyright>© 2026 <span class=\"small-caps\">ad</span> / <a href=\"https://en.wikipedia.org/wiki/French_Republican_calendar\">234 <span class=\"small-caps\">ar</span></a> Joar von Arndt</copyright>
        </div>
        <div class=\"footer-lower\">
        <nav>
          <ul>
            <li><a href=\"https://joarvarndt.se/about.html\">About</a></li>
            <li><a href=\"https://joarvarndt.se/archive.html\">Archive</a></li>
            <li><a href=\"https://joarvarndt.se/links.html\">Your next stop</a></li>
            <li><a href=\"https://joarvarndt.se/website.html\">Colophon</a></li>
          </ul>
        </nav>

        <nav>
          <ul>
            <li><a href=\"https://joarvarndt.se/now.html\">Now</a></li>
            <li><a href=\"https://joarvarndt.se/subscribe.html\">Subscribe</a></li>
            <li><a href=\"https://joarvarndt.se/contact.html\">Contact</a></li>
            <li><a href=\"https://webmention.io/joarvarndt.se/webmention\">Webmentions</a></li>
          </ul>
        </nav>
    <script src=\"static/theme.js\" defer></script>
    </div></div></div>")

The header and footer of each page. The header is very plain — it only includes the heraldic achievement that acts as a “home” link. The table of contents that appears on some pages (including this one) is a part of the post itself and is generated by org-mode’s export functionality. It simply moves to the top of the page using css and is not part of the header.

The footer has comparatively quite a lot going on. Its multi-column design was inspired principally by Jonas Hietala, from whom I was also partly inspired by the choice of using git to track post changes (although the idea of tracking changes to a post came from Appleton’s “planted X time ago”). I also chose to prominently display webmentions as a technology since they are used by an unfortunately few number of people, and I myself often forget to check if a site does or not when linking to them.

(setq org-static-blog-index-front-matter "<site-intro><p>
      This is the site of Joar Alexander Pablo von Arndt. I write about a
      variety of topics, from coverage of <a href=\"https://joarvarndt.se/eww.html\"><span class=\"small-caps\">gnu</span> Emacs web browsing</a>, to <a href=\"https://joarvarndt.se/business_cards.html\">graphic
      design</a> and <a href=\"https://joarvarndt.se/european-tech.html\">critiques of industrial policy</a>. You can <a href=\"https://joarvarndt.se/subscribe.html\"> subscribe here</a>. If you enjoy anything written here (or disagree with me) feel free to <a href=\"https://joarvarndt.se/contact.html\">tell me about it</a>.
      </p>
      <ul class=\"org-ul\">
      <li><a href=\"https://joarvarndt.se/archive.html\" class=\"archive-link\">All Posts</a></li>
      </ul>
      <p>
      My own personal favorites are the following:
      </p>

      <ul class=\"org-ul\">
      <li><a href=\"https://joarvarndt.se/end-of-history.html\"><i>The End of History.</i></a></li>
      <li><a href=\"https://joarvarndt.se/email.html\"><i>Email as a Revolutionary Medium</i></a></li>
      <li><a href=\"https://joarvarndt.se/deepseek.html\"><i>Deepseek is not a Chinese OpenAI</i></a></li>
      </ul>

      <nav id=\"table-of-contents\" role=\"doc-toc\">
        <h2><i>Itinerarium</i></h2>
        <div id=\"text-table-of-contents\" role=\"doc-toc\">
          <ul>
            <li><a href=\"https://joarvarndt.se/archive.html\">All Posts</a></li>
            <li><a href=\"https://joarvarndt.se/about.html\">About</a></li>
            <li><a href=\"https://joarvarndt.se/now.html\">Now</a></li>
            <li><a href=\"https://joarvarndt.se/links.html\">Your next stop</a></li>
            <li><a href=\"https://joarvarndt.se/subscribe.html\">Subscribe</a></li>
            <li><a href=\"https://joarvarndt.se/website.html\">Colophon</a></li>
          </ul>
        </div>
      </nav>
</site-intro>")

This is the hand-crafted html for the index page, that itself has no corresponding org-mode file. It is generated on each rebuild with this introduction and a series of posts governed by org-static-blog-index-length. The itinerarium that acts as a sort of site-menu is formatted like a custom table of contents for the index page.

(setq org-static-blog-archive-front-matter "<picture>
        <source srcset=\"https://joarvarndt.se/bird-butterfly.webp\" type=\"image/webp\">
        <source srcset=\"https://joarvarndt.se/bird-butterfly.png\" type=\"image/png\">
        <img src=\"https://joarvarndt.se/bird-butterfly.png\"
          alt=\"A small bird resting amongst the branches, gazing at a flying butterfly.\"
          class=\"pictograph\">
      </picture> <hr>")

Finally another custom-fork-feature; archive front matter! This can be used to display anything on the page listing all of the posts, but here I use it to insert a beautiful illustration that I got from Tom Chalky.³

The above lisp code is not just a series of example code snippets, it is directly the code that is used to build the website! The text you are reading right now is written as an org-mode document, and the code blocks above are exported into a corresponding Emacs lisp file and run as part of the build process. Because it became annoying to manually evaluate the above code block every time I wanted to export I wrote a quick build script, whose contents can easily be embedded⁴ into this post like this:

#+INCLUDE: "~/Documents/blog/build" src emacs-lisp

#!/usr/bin/env -S emacs -x

;;; Code:

(package-initialize)
(message "Initialized package.el")

(require 'org)
(require 'cal-french)
(require 'htmlize)
(message "Loaded libraries")

(org-babel-tangle-file "~/Documents/blog/posts/website.org")
(load-file "~/Documents/blog/posts/website.el")

(load-file "~/programming/org-static-blog/utils.el")
(load-file "~/programming/org-static-blog/org-static-blog.el")

(org-static-blog-publish)

;;; build ends here

This makes use of the very underused scripting capabilities of Emacs (#!/usr/bin/emacs -x), allowing you to use the power of lisp combined with Emacs’ extensive libraries. It also loads my personal fork of org-static-blog that makes some small opinionated changes (like the git-edit and french republican dates). The french republican dates are one of the clearest examples of the usefulness of Emacs as a standard library — Emacs ships with a library to translate to and from the french republican calendar.

I am a big fan of org-static-blog due to its simplicity⁵, extensibility (it is just a simple html static site generator) and obvious org-mode support. That I wrote my own fork is testament to the great work done by Bechtold. It is incredibly featureful, simple to read and to modify. If you ever wonder how a given piece of html is generated you can quickly C-s around in the source code (all of which is in a single file) between function definitions and implementations.

It is also quite fast — the majority of the build script is usually just start-up time from Emacs loading libraries — but not fast enough to offer anything like real-time previews. Unless org-static-blog-publish is called with a prefix argument⁶ it will only re-render those files that have actually changed and thus doesn’t take very long to re-render the site. Only when tinkering with site-wide html changes (such as for the footer) do I need to re-render everything, and even then it just takes a few seconds.

I used to use Hugo, a widely praised static website generator, but it only has nominal org-mode support and requires a special non-org-mode yaml frontmatter that I really dislike. When writing a post, I prefer to leave formatting mostly out of it, and with my main focus on text. Tinkering with the website’s appearance is great fun of course, but I like to keep the two as separate activities. Keeping them separate means that if I improve the appearance of a new post all previous posts also benefit. Writing any sort of special syntax also brings me out of the experience, and that is partly why I wrote my own javascript to create sidenotes out of basic pandoc (and therefore org-mode) style footnotes instead of using tufte-css.

The website used to be hosted on my own server at home, on an Intel nuc machine, running at first nginx and then Caddy.⁹ After I experienced a 25 day long downtime in June 2025 when I was traveling in China I however decided to not host the public-facing blog from home. These types of downtimes are not acceptable to me and my residential internet connection is simply too unreliable to maintain a high uptime anyways. For that reason I have moved the blog to Netlify but still retain the server for hosting personal services and experiments.

Netlify requires a git repository at one of a small list of git forges, so I have a private repository of the blog on Github that is automatically pushed to from the main repository on Codeberg.

I use loopia as my domain registrar, primarily due to having been recommended them from someone I trust, however I have made no significant research into alternatives myself.

I use magit to interact with git and push changes to the blog to a remote repository that then causes netlify to update. ❦