glfmn.io

git-clone

2026-04-02T00:00:00+00:00
Reading Code</h2>
I find that I spend a lot of time reading code when I am learning a new topic. I used to mostly browse, search, and read code from repositories through GitHub's web view. However, GitHub restricted searching code to logged-in accounts a while back, and has become increasingly punitive about rate limits. GitHub's web interface is now basically unusable for me.</p>

git clone</h2>
However, this has gotten me into the habit of just calling `git clone https://github.com/project/path</code> when I want to dig deeper. It turns out, just having the code on my computer is way better!</p>`
`I don't need a consistent internet connection</li> No rate limits or walled off sections</li> Easier to go to a specific head commit</li> Much easier to read commit history</li> I can build and edit the code</li> My editor can display it side-by-side</em> with the code I am writing</li> </ul> I wonder how I even got into the habit of using the web interface so heavily in the first place.</p> Don't browse, git clone</code> instead.</p>`



html-is-a-tree
2025-10-23T00:00:00+00:00
Introduction</h2>
A long while ago, I used clojure</code> for some web development and used
hiccup-style html templates for the first time. For the uninitiated, clojure</code>
is a lisp</abbr> dialect. This makes it possible
to directly represent tree structures. For example, here is an HTML document:</p>
[</span>:html</span></span>
 [</span>:head</span></span>
  [</span>:link</span> {</span> :rel</span> "</span>stylesheet</span>"</span> :href</span> "</span>/style.css</span>"</span> }</span>]</span>]</span></span>
 [</span>:body</span></span>
  [</span>:article</span></span>
   [</span>:h1</span> "</span>Hello world!</span>"</span>]</span></span>
   [</span>:p</span> "</span>This clojure data structure directly encodes an HTML document.</span>"</span>]</span>]</span>]</span>]</span></span></code></pre>
One can do more than just write static documents this way, as it becomes very
easy to directly inject new structure using code:</p>
(</span>let</span> [</span>posts</span> (</span>load-documents</span> "</span>posts/**/*.md</span>"</span>)</span>]</span></span>
 [</span>:html</span></span>
  [</span>:head</span></span>
   [</span>:link</span> {</span> :rel</span> "</span>stylesheet</span>"</span> :href</span> "</span>/style.css</span>"</span> }</span>]</span>]</span></span>
  [</span>:body</span></span>
   [</span>:article</span></span>
    [</span>:h1</span> "</span>Hello world!</span>"</span>]</span></span>
    [</span>:h2</span> "</span>Read my articles</span>"</span>]</span></span>
    [</span>:ol</span> (</span>map</span></span>
          (</span>fn</span> [</span>post</span>]</span> [</span>:li</span> (</span>post-summary</span> post</span>)</span>]</span>)</span></span>
          posts</span>)</span>]</span>]</span>]</span>]</span>)</span></span></code></pre>
When the whole document has a uniform and consistent representation, it becomes
easy to transform and manipulate. Want to iterate every heading in the doc and
make a table of contents? Easy. Want to collect every link, check if it has
metadata, and make a list of citations at the bottom of your page? Easy.</p>
I haven't used a static site generator that fully embraced this, but I never
tried really hard to find one since I had zola</a> and was satisfied, and I knew
it would take a lot of work to migrate.</p>
I also had some big concerns which nagged away at me:</p>

scss</code></dt>
I use scss to write my stylesheets, and didn't want to make the huge
undertaking of translating to raw css if necessary.</dd>
markdown</code></dt>
I write my aritcles with markdown, and translate that to HTML, but I also use a
lot of HTML and shortcodes</a> embeded within</em> my markdown documents.</dd>
clojure</code></dt>
clojure</code> (and most LISPs) feel like a heavy dependency, and I didn't want to
deal with complicated language setup in addition to</em> complicated dependency
management for the site generator itself. A single binary that I can easily
compile or install from my package manager is very very</em> hard to beat.</dd>
</dl>
Interstingly, each of these concerns has diminished over time. This has me
evaluating my options again.</p>
Just Use CSS</h2>
I found an article called You no longer need JavaScript</a> which showed just how
far CSS had come. The standard has adopted almost everything I use scss</code> for:</p>

I already make heavy use of CSS variables</li>
It turns out nesting is standards compliant now</li>
</ul>
I really could</em> just write this site in plain CSS if I wanted to now, and I
don't expect I would lose much of anything. I use scss @mixins</code> in a couple of
places, but I think it would be possible to use a simpler solution.</p>
Limitations of Markdown and Zola</h2>
While text makes up the majority of my documents, I keep finding nice HTML
elements like <dl></code> that I want to use, which markdown cannot represent.</p>
I also find that I need nice ways to express structural data and freely mix
structured data and text. Markdown doesn't do this well since it only really
supports inline HTML which is verbose, or shortcodes</a> which are limited.
Markdown also doesn't allow attributes on elements, which is niche for me, but
useful.</p>
One</em> recent pain-point: If I leave extraneous whitespace in some parts of
my document, the markdown parser will read code as a preformatted text block
instead of HTML or some other a [shortcode] (due to the 4 leading space rule).</p>
If I put the following inside my markdown document:</p>
<</span>style</span>></span></span>
figure</span> {</span></span>
  display</span>:</span> block</span>;</span></span>
</span>
  figcaption</span> {</span></span>
    display</span>:</span> block</span>;</span></span>
    padding-top</span>:</span> 1</span>em</span>;</span></span>
</span>
    p</span> { </span>color</span>:</span> var</span>(</span>--fg2</span>)</span>;</span> }</span></span>
  }</span></span>
}</span></span>
</</span>style</span>></span></span></code></pre>
The nested p</code> selector inside the figcaption</code> has 4 leading spaces and a new
line in front, making it a code block, resulting in the following html:</p>
<</span>style</span>></span></span>
figure</span> {</span></span>
  display</span>:</span> block</span>;</span></span>
</span>
  figcaption</span> {</span></span>
    display</span>:</span> block</span>;</span></span>
    padding-top</span>:</span> 1</span>em</span>;</span></span>
<</span>pre</span>></span></span>
<</span>code</span>></span></span>
p</span> { </span>color</span>:</span> var</span>(</span>--fg2</span>)</span>;</span> }</span></span>
</</span>code</span>></span></span>
</</span>pre</span>></span></span>
  }</span></span>
}</span></span>
</</span>style</span>></span></span></code></pre>
This is easy (though annoying) to avoid when writing the document directly, but
quite difficult to avoid with shortcodes</a>. Sometimes, they have non-trivial
template statements inside them. If I fail to use the proper whitespace-removal
sytanx, the output</em> of a shortcode may trigger a 4-space codeblock.</p>
shortcodes</a> are not like lisp macros. They do not operate on the
AST</code></abbr> or structure</em> of the document,
they produce a soup of letters</a>. This makes post-processing
impossible as well!</p>
Do I need markdown?</h2>
The thing is, while I do need a way to write mostly text documents conviniently,
I don't necessarily need to use markdown. What I really want, is some way to
transform a lightweight document into some sort of tree structure, and then
perhaps transform that</em> tree structure into HTML.</p>
For example, I would like to transform a document like this:</p>
##</span> Hobbies</span></span>
</span>
My current hobbies include:</span></span>
</span>
-</span> 3D art</span></span>
-</span> live coding</span></span>
-</span> sewing </span>&</span> embroidery</span></span>
-</span> blogging</span></span>
</span>
But in the past I have enjoyed pottery, bookbinding, and sculpture.</span></span>
I am always working on projects and endeavor to write about them</span></span>
from time to time.</span></span></code></pre>
Into a data structure like this:</p>
[</span>:section</span></span>
 [</span>:h1</span> "</span>Hobbies</span>"</span>]</span></span>
 [</span>:p</span> "</span>My current hobbies include:</span>"</span>]</span></span>
 [</span>:ul</span></span>
  [</span>:li</span> "</span>3D art</span>"</span>]</span></span>
  [</span>:li</span> "</span>live coding</span>"</span>]</span></span>
  [</span>:li</span> "</span>sewing & embroidery</span>"</span>]</span></span>
  [</span>:li</span> "</span>blogging</span>"</span>]</span>]</span></span>
 [</span>:p</span> "</span>But in the past I have enjoyed pottery, bookbinding, and sculpture.</span></span>
I am always working on projects and endeavor to write about them</span></span>
from time to time.</span>"</span>]</span>]</span></span></code></pre>
And then process that somehow, perhaps rendering it to HTML, perhaps not. Ideally,
the scripting would operate on the level of AST nodes.</p>
A lisp-y scripting language feels like the perfect fit for something like this.</p>
As it turns out, people have already experimented with writing mostly-text
documents with lisp code inside; for example, skribe</a>! It looks something like
this:</p>
(p [Everything inside square brackets is text, but one can inject code by using</span></span>
lisp's ,(code "unquote") form: 1+4=,(+ 1 4)])</span></span></code></pre>
This is missing some of the niceities of markdown, but I find the idea of using
something like ,()</code> to inject code which outputs new syntax nodes compelling!</p>
Enter Janet</h2>
At this point, the ideas were milling about in my head already and zola</a>'s
limitations were getting harder to deal with. I found haunt</a>, which seemed to
do what I wanted, but I wasn't able to install it so I gave up.</p>
Then I found janet</a>! It was super easy to install, and it takes a lot of
inspiration from clojure</code>, which is good since I've used clojure before. I got
hacking away and was able to convert tuples to HTML in a day!</p>
(</span>defn</span> html</span>/</span>void-tag?</span> [</span>tag</span>]</span> (</span>in</span> html</span>/</span>void-tags</span> tag</span>)</span>)</span></span>
</span>
(</span>def-</span> tab</span> "</span>  "</span>)</span></span>
</span>
(</span>defn-</span> align</span> [</span>i</span>]</span> (</span>string</span> "</span>\n</span>"</span> (</span>string/repeat</span> tab</span> i</span>)</span>)</span>)</span></span>
</span>
(</span>defn</span> html</span>/</span>attribute</span> [</span>key</span> value</span>]</span> (</span>string/format</span> "</span> %s=</span>\"</span>%s</span>\"</span>"</span> key</span> value</span>)</span>)</span></span>
</span>
(</span>defn</span> html</span>/</span>attributes</span> [</span>dict</span>]</span></span>
  (</span>reduce</span></span>
    (</span>fn</span> [</span>i</span> [</span>k</span> v</span>]</span>]</span> (</span>string</span> i</span> (</span>html/attribute</span> k</span> v</span>)</span>)</span>)</span></span>
    "</span>"</span></span>
    (</span>pairs</span> dict</span>)</span>)</span>)</span></span>
</span>
(</span>defn</span> html</span>/</span>void</span> [</span>indent</span> name</span> attr</span>]</span></span>
  (</span>string</span> (</span>align</span> indent</span>)</span> "</span><</span>"</span> name</span> (</span>html/attributes</span> attr</span>)</span> "</span> /></span>"</span>)</span>)</span></span>
</span>
(</span>defn</span> html</span>/</span>open</span> [</span>indent</span> name</span> attr</span>]</span></span>
  (</span>string</span> (</span>align</span> indent</span>)</span> "</span><</span>"</span> name</span> (</span>html/attributes</span> attr</span>)</span> "</span>></span>"</span>)</span>)</span></span>
</span>
(</span>defn</span> html</span>/</span>close</span> [</span>indent</span> name</span>]</span></span>
  (</span>string</span> (</span>align</span> indent</span>)</span> "</span></</span>"</span> name</span> "</span>></span>"</span>)</span>)</span></span>
</span>
(</span>defn</span> html</span>/</span>render</span> [</span>indent</span> el</span>]</span></span>
  (</span>let</span> [</span>element</span> (</span>fn</span> [</span>tag</span> attr</span> children</span>]</span></span>
        (</span>cond</span></span>
          (</span>and</span> (</span>not</span> (</span>empty?</span> children</span>)</span>)</span> (</span>html/void-tag?</span> tag</span>)</span>)</span></span>
            (</span>error</span> (</span>string</span> "</span>Void element </span>\"</span>:</span>"</span> tag</span> "</span>\"</span> declared with children</span>"</span>)</span>)</span></span>
          (</span>in</span> html</span>/</span>void-tags</span> tag</span>)</span> (</span>html/void</span> indent</span> tag</span> attr</span>)</span></span>
          (</span>string</span></span>
            (</span>html/open</span> indent</span> tag</span> attr</span>)</span></span>
            ;</span>(map (fn [child] (html/render (+ 1 indent) child)) children)</span></span>
            (</span>html/close</span> indent</span> tag</span>)</span>)</span>)</span>)</span>]</span></span>
   (</span>match</span> el</span></span>
     (</span>[</span>tag</span> attr</span> & </span>children</span>]</span> (</span>dictionary?</span> attr</span>)</span>)</span></span>
       (</span>element</span> tag</span> attr</span> children</span>)</span></span>
     [</span>tag</span> & </span>children</span>]</span></span>
       (</span>element</span> tag</span> {</span>}</span> children</span>)</span></span>
     [</span>tag</span>]</span></span>
       (</span>element</span> tag</span> {</span>}</span> [</span>]</span>)</span>)</span>)</span>)</span></span></code></pre>
It's so</strong> nice! And it was not too painful to write. This:</p>
(</span>print</span></span>
 (</span>html/render</span> 0</span></span>
  '</span>[</span>:html</span></span>
    [</span>:head</span> [</span>:meta</span> {</span>}</span>]</span>]</span></span>
    [</span>:body</span> {</span>:class</span> "</span>name</span>"</span>}</span>]</span>]</span>)</span>)</span></span></code></pre>
Outputs this:</p>
<</span>html</span>></span></span>
  <</span>head</span>></span></span>
    <</span>meta</span> /></span></span>
  </</span>head</span>></span></span>
  <</span>body</span> class</span>=</span>"</span>name</span>"</span>></span></span>
  </</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
The translator doesn't properly handle text elements or escaping, but I think
the proof-of-concept of representing the tree-structure of HTML is a success.</p>
Hare-Brained Scheme</h2>
At this point, I started having ideas</em>. janet</a> is insanely cool! I decided
to dig into the janet</a> C api via zig</code>. It was super easy to install the
development package through my system package manager and link to it in a
build.zig</code> file.</p>
It took a bit more work to figure out how to actually run</em> janet code from
within zig, but I was able to create a function which calls std.log.debug</code>,
call that from janet</a> code that I called from zig.</p>
The ouroboros</strong> was complete, and I realized that I could potentially create
a pretty good static-site generator that takes inspiration from zine</code> and
std.Build</code>, but using janet</a> as the orchestration and templating/translation
language.</p>
The entry point could be a build.janet</code> file, which exposes a builder API that
defines the dependency graph of the site, registering janet functions as the
"build pipeline" to transform files from 1 representation into to another until
they get "installed" to the build directory.</p>
I could write a function that parses md</code> or orgdown</a> into a janet</a> tuple,
splatting code inside ,()</code> forms right into the data.</p>
Since janet</a> also lets one create handlers to use when import</code>ing files, I
could maybe re-use the import</code> functionality to register those</em> files in the
dependency graph for rebuild and watch support.</p>
Suddenly things are feeling dangerously exciting!</p>
And that is where I am now. I intend to prototype this in the most janky,
single-threaded way possible and see where it goes :)</p>


email-fail
2025-09-13T00:00:00+00:00
Description</h2>
I've had a good experience with email exactly once. But it had a fatal flaw.</p>
I struggle with email</h2>
The more time passes, the more I struggle with email. My inbox grows faster
than I can deal with it. Mostly spam I never signed up for, emails that are
irrelevant after a few days, or emails where I already know everything I need
to know from glancing at the subject. And worse: the more time passes, the less
patience and focus I seem to have for dealing with useless emails.</p>

ADHD</h3>

I recently got diagnosed with ADHD, and I think that has a lot to do with my
relationship with email. There's something about the default mail interface that
destroys my executive function.</p>

</div>
</aside>
I have always been on the lookout for a way to actually make email work better
for me. One day, when I heard about an email system called notmuch</a> that could
handle a million emails quickly and without slowing down. I decided to try it
out!</p>
A Golden Age, of a kind</h2>
The notmuch</a> interface that I tried is actually embedded inside Emacs</a>.
It gives you nothing but a search bar. Instead of an inbox, you add a set of
default searches</em> to the start screen. Each default search you add gets a
button and a count of how many emails match the query.</p>
The key insight is that you should only see emails you are looking for!</strong></p>
By comparison, webmail shows you an inbox with everything, and you have to sort
email out</em> with rules. I find it easier to describe what I want than what I
don't want.</p>
Webmail is also painfully slow, requiring internet. I've also not seen a webmail
client that expresses batch operations well.</p>
The default mode of notmuch</a> is batch mode! You can trivially do every
operation on thousands of emails (if you need to, and I have in practice).
notmuch</a> even has a handy scripting interface, for using queries to apply tags
automatically. Filters, but way better and more expressive when used sparingly.</p>
It was amazing, but sadly it was not fated to last.</p>
The Fatal Flaw</h2>
I have lied a little. notmuch</a> is not an email client. It only does mail indexing.
The client was an Emacs</a> package. Furthermore, notmuch</a> does not
fetch email</a>.</p>
Following the Unix Philosophy, it does 1 thing and 1 thing ridiculously well:
index & tag emails.</p>
This is beautiful. But it is also painful.</strong></p>
The Unix philosophy works well for APIs, for command line tools, but I
don't think it works for email. At least not for me. I want a flexible email
experience, but I don't want to engineer my emails.</p>
notmuch</a>, offlineimap</a>, Emacs</a>, and
notmuch-emacs</a> each have
complex installation</a>, configuration, and maintenance!</p>
These are the tools for making a great email client, they are not a great email
client.</p>
And worse, you have to do it again for a different machine! And set up
yet another utility</a> to sync your tags between machines.</p>
Our non-techie friends deserve an email experience that is just as fast and flexible
as what notmuch</a> affords. This is my plea that someone will manage to take
these tools and package them all together in a way that is even easier to set up
than Thunderbird</a>.</p>
At least for me, the "Unix way" of handling email is worse-is-better in
disguise. And worse isn't better for me. It feels like we need to gather all of
these amazing open source developers in one room to make something cohesive, and
I wish I had the money or power or charisma to make that happen.</p>
Closing Notes</h2>
I am writing this after trying to use aerc</a> for
sourcehut's git send-email workflow</a>. It kinda does what I hoped for: it syncs
email, has an inbox, and composition view. It really does feel like a wrapper
that manages the same underlying primitives mentioned above.</p>
Unfortunately, aerc</a> emulates the interface of webmail in the terminal.
For me, this has the same workflow and focus problems. I also found it a
bit janky in practice. The hotkey choices feel unintuitive (I know they are
configurable), and I kept having issues where it would fail to send an email and
seemingly discard the message I had just composed. There were also holes in the
documentation (that I might send some patches for if I can figure out how to send
emails with git).</p>
I may try neomutt</a> next, but I honestly want something slightly</em> more than a
terminal. A lot of mostly</em> text user interfaces need just a bit more, and Emacs
gets the balance just right focusing on textbut giving you just a bit more.
Unfortunately, Emacs can feel as heavy as an electron application!</p>


links
2025-09-11T00:00:00+00:00
Description</h2>
Inspired by matklad</code></a> and Drew DeVault</a>, I wanted a permenant place to
collect links that have helped me in order to build knowledge and signal boost
them.</p>
Live Coding</h2>


  What is live coding?</link-item-title>
</dt>

  https://blog.toplap.org/about/</a>
  
Live coding is a new direction in electronic music and video, and is getting
somewhere interesting. Live coders expose and rewire the innards of software
while it generates improvised music and/or visuals. All code manipulation
is projected for your pleasure. Live coding works across musical genres, and
has been seen in concert halls, late night jazz bars, as well as algoraves.
There is also a strong movement of video-based live coders, writing code to
make visuals, and many environments can do both sound and video, creating
synaesthetic experiences.</p>
</blockquote>

</dd>

  TOPLAP Manifesto Draft</link-item-title>
</dt>

  https://toplap.org/wiki/ManifestoDraft</a>
  This manifesto is partly toungue in cheek, but it does underscore some of the
values and ideas behind live coding.
</dd>
</dl>
Graphics</h2>


  Rendering Crispy Text on The GPU</link-item-title>
</dt>

  https://osor.io/text</a>
  How to render text on the GPU, focused on the parts that I find interesting.
With a number of surprisingly elegant tricks.
</dd>

  Avoiding Trigonometry</link-item-title>
</dt>

  https://iquilezles.org/articles/noacos/</a>
  Insights on how to make graphics programming simpler by using vectors more.
</dd>

  Shader Basics, Blending & Textures</link-item-title>
</dt>

  https://www.youtube.com/watch?v=kfM-yu0iQBk</a>
  A great intro to how shaders work, from the shader sorceress herself.
</dd>

  Graphics Studies Compilation</link-item-title>
</dt>

  https://www.adriancourreges.com/blog/2020/12/29/graphics-studies-compilation/</a>
  Arain Courrèges and others break down how various different games render their
scenes, with expert commentary.
</dd>

  How I learned Vulkan and wrote a small game engine with it</link-item-title>
</dt>

  https://edw.is/learning-vulkan/</a>
  Learning Vulkan is not impossible if you avoid OOP.
</dd>

  How I learned Vulkan and wrote a small game engine with it</link-item-title>
</dt>

  https://edw.is/learning-vulkan/</a>
  Learning Vulkan is not impossible for a solo dev.
</dd>

  It's not the API</link-item-title>
</dt>

  https://www.youtube.com/live/zYAif5PhhoQ?t=21434</a>
  Vulkan can potentially be simpler if you embrace first principles.
</dd>

  Vulkan with Wayland</link-item-title>
</dt>

  https://amini-allight.org/post/using-wayland-with-vulkan</a>
  Using Wayland directly with Vulkan is a bit daunting. Worse, it is hard to
find an example that doesn't use C++ classes or split everything into too many
abstractions. Amini Allight to the rescue with a blog post and a
single .c file.</a>.
</dd>

  Image presentation in libvulkan_intel.so</link-item-title>
</dt>

  https://badland.io/vulkan-swapchain.md</a>
  A small peak into how the vulkan driver uses linux kernel APIs to render images
to the screen.
</dd>

  Mesa Wayland WSI imlpementation</link-item-title>
</dt>

  https://gitlab.freedesktop.org/mesa/mesa/-/blob/8730c039bf37e8dba25ae76067dda68a1ab6a870/src/vulkan/wsi/wsi_common_wayland.c</a>
  Mesa's Vulkan WSI implementation for vulkan, where one can see how the wayland
surface interacts with the swapchain under the hood.
</dd>

  Vulkan Loader docs for Application Developers</link-item-title>
</dt>

  https://vulkan.lunarg.com/doc/sdk/1.4.328.1/windows/LoaderApplicationInterface.html</a>
  What you should understand about the LunarG vulkan loader as an application
developer, namely how to link it, and what it does.
</dd>

  Wayland Linux DMA-BUF protocol</link-item-title>
</dt>

  https://wayland.app/protocols/linux-dmabuf-v1</a>
  Passing buffers owned by the linux graphics subsystem. See also
the kernel documentation</a>
</dd>
</dl>
Software Development</h2>


  Contempt Culture</link-item-title>
</dt>

  https://blog.aurynn.com/2015/12/16-contempt-culture</a>
  On the phenomenon of programming communities which signify values and group
membership through contempt.
</dd>
</dl>
System Administration</h2>


  Consolidated Guide to Using Yubikeys with Linux</link-item-title>
</dt>

  https://marcusb.org/posts/2024/03/consolidated-guide-to-using-yubikeys-with-linux/#remotesudo</a>
  A guide to going passwordless with yubikeys. Having dabbled in this, I really
wish it was more seamless!
</dd>
</dl>
Society</h2>


  You Can't Fight Enshittification</link-item-title>
</dt>

  https://pluralistic.net/2025/07/31/unsatisfying-answers/</a>
  I've noticed a lot of people in discussions miss the key meaning behind the term
Enshittification</em>: Enshittification is deliberate and systemic. We can't stop
it by just writing better software!
</dd>

  The Male Glance</link-item-title>
</dt>

  https://www.vqronline.org/spring-2018/essays/male-glance</a>
  If The Male Gaze</em> is a pre-occupation with women's physical appearance, The
Male Glance</em> is the dismissal of women's work and art as shallow and unworthy of
deeper consideration.
</dd>
</dl>
Web Development</h2>


  You no longer need JavaScript</link-item-title>
</dt>

  https://lyra.horse/blog/2025/08/you-dont-need-js/</a>
  Some really cool things one can do with CSS and HTML that have me rethinking
how I write this blog.
</dd>

  Against Horizontal Scroll</link-item-title>
</dt>

  https://matklad.github.io/2025/04/22/horizontal-scroll.html</a>
  Tips on preventing horizontal scroll for websites.
</dd>

  Data Oriented Blogging</link-item-title>
</dt>

  https://matklad.github.io/2023/11/07/dta-oriented-blogging.html</a>
  Touches on something I have felt which is that a lot of static site generators
ignore the tree-based nature of HTML, which makes writing structured documents
harder.
</dd>

  Producing HTML using string templates has always been the wrong solution</link-item-title>
</dt>

  https://www.devever.net/~hl/stringtemplates</a>
  An instrumental document in helping me understand why I don't like hugo style
shortcodes.
</dd>
</dl>
Video Games</h2>


  Game Wikis</link-item-title>
</dt>

  https://getindie.wiki/listings/</a>
  A listing of classic, honest-to-goodness video game wikis. None of the SEO
optimized, add-stuffed "fandom" sites.
</dd>
</dl>
WebComics and Graphic Novels</h2>
I read a lot of webcomics and graphic novels, here are some of my favorites:</p>


  Kill Six Billion Demons</link-item-title>
</dt>

  https://killsixbilliondemons.com/comic/ksbd-chapter-1-1/</a>
  KILL SIX BILLION DEMONS!
</dd>

  Dark Science</link-item-title>
</dt>

  https://dresdencodak.com/2010/06/03/dark-science-01/</a>
  Captures something fascinating about living in the age of social media. Also gay
as hell.
</dd>

  3rd Voice</link-item-title>
</dt>

  https://rice-boy.com/3rdvoice/</a>
  Interesting fantasy post apocalypse.
More than 1 great webcomic on this site! Also, peak webcomic site design.
Everyone do it like this please.
</dd>

  What Happens Next</link-item-title>
</dt>

  https://whathappensnext.webcomic.ws/comics/1</a>
  Deconstruction of true crime, with prominent trans themes.
</dd>

  Ava's Demon</link-item-title>
</dt>

  https://avasdemon.com/pages.php#0001</a>
  Beautifully illustrated comic about mental illness and tyranny.
</dd>

  The Guy She Was Interested In Wasn't a Guy At All</link-item-title>
</dt>

  https://dynasty-scans.com/series/the_guy_she_was_interested_in_wasnt_a_guy_at_all</a>
  The title says it all: cute queer romance.
</dd>

  Gunerkrigg Court</link-item-title>
</dt>

  https://www.gunnerkrigg.com/?p=1</a>
  British Magic School, but with a unique tone, setting, and concept.
</dd>
</dl>


handmade-livecode.txt
2025-08-16T00:00:00+00:00
glfmn.io

git-clone

html-is-a-tree

email-fail

Description</h2> I've had a good experience with email exactly once. But it had a fatal flaw.</p>

links

Live Coding</h2> What is live coding?</link-item-title> </dt>

Graphics</h2> Rendering Crispy Text on The GPU</link-item-title> </dt>

Software Development</h2> Contempt Culture</link-item-title> </dt>

System Administration</h2> Consolidated Guide to Using Yubikeys with Linux</link-item-title> </dt>

Society</h2> You Can't Fight Enshittification</link-item-title> </dt>

Web Development</h2> You no longer need JavaScript</link-item-title> </dt>

Video Games</h2> Game Wikis</link-item-title> </dt>

WebComics and Graphic Novels</h2> I read a lot of webcomics and graphic novels, here are some of my favorites:</p>

handmade-livecode.txt

Description</h2>
I've had a good experience with email exactly once. But it had a fatal flaw.</p>
