Gorilla Newsletter 95

Welcome back everyone 👋 and a heartfelt thank you to all new subscribers who joined in the past week!

This is the 95th issue of the Gorilla Newsletter—a weekly online publication that sums up everything noteworthy from the past week in generative art, creative coding, tech, and AI.

If it's your first time here, we've also got a Discord server where we nerd out about all sorts of genart and tech things — if you want to connect with other readers of the newsletter, come and say hi: here's an invite link!

That said, cue the news 👇

All the Generative Things

1 — The HTML Review 2025: the html review is a collection of artful, poetic, and web native pieces of story-telling — or more simply: an annual journal of literature made to exist on the web.

This year features a series of very personal, somewhat esoteric, web experiences that act as direct commentaries on our digital existences on the web, where the storytelling deeply is intertwined with the tech itself. A couple of my favorites this time round:

Navigation Queues Navigation Cues doesn't only tell you the history of scrollbars but also comments on the contemporary role that scrolling plays in our lives, how it's no longer an active act of exploration, but rather a way for getting lost.
Cavity! tells its story in a non-sequential manner, simply by letting you uncover the individual text nodes, but still conveying a sense of sequence through the graph structure in the background — that I believe you are meant to disentangle.
In I want my computer to forget like I do the author downloads their files onto the viewers machine in an irreversible manner — tasking you with holding on to and safekeeping them until they might be needed again in the future. Thank you for the digital burden... 😅

But that's just a few of the works that I personally enjoyed among many others. I highly recommend taking a few moments and checking them out for yourself. Also have a look at the HTML reviews of previous years — I covered the 2024 issue in newsletter #49.

2 — The Rivulet Programming Language: if it weren't for the HTML review, this one would have easily taken the top spot in this week's roundup — Rivulet is an esoteric, list-based programming language that encodes its operations as flowing semigraphic character strands within block-like glyphs.

Glyphs can be arranged vertically or horizontally, delineated by a beginning marker ╵ in the upper left corner and ending with a ╷ at the bottom right — different instructions are then executed as the glyph is traversed.

Four different types of strands specify what instructions should be executed: value strands write numbers into lists, reference strands point to specific cells, action strands that modify these values using arithmetic operations, and paired question strands that test conditions.

So instead of traditional loops or if-statements, every strand in a glyph runs in a set visual order where the layout itself dictates the program’s logic and execution, with conditional branching and rollbacks, creating an interesting maze-like flow.

If you're interested, check out the official GitHub repo.

3 — The DDA Algorithm: in a nutshell, the Digital Differential Analyzer (DDA) algorithm is an efficient method for drawing straight lines on our screens — which, as you might be aware of, are discrete pixel grids. In essence, it lets us determine which pixels need to be turned on to visualize lines, based on how the line at hand arithmetically travels through these pixels.

While its effect is rather simple to grasp, implementing it can be a bit tricky because it involves quite a bit of math; that's why Joshua Michael wrote this wonderful interactive article about the algorithm showing us all the small mathematical parts that make it work.

4 — Our interfaces have lost their senses: Amelia Wattenberger writes as beautifully as ever, in her most recent post she talks about how our digital interfaces have become increasingly flat and text-based, stripping away the texture, sound, and tactile feedback that make interactions more organic, immersive, and satisfying.

The key-takeaway here is that different modalities of interaction that play into our sense can potentially allow for richer ways to manipulate our daily digital playgrounds, and align more with the way our brains function and the ways that we think.

5 — DIY Synths Database: while we're talking about being hands-on, check out this collection of 50+ standalone open source synth builds, ranging from newbie projects all the way to more complex ones.

Each synth listed links to a project page over on GitHub where you can find the required materials, 3D printables, instructions on how to assemble it, and everything else you might need.

I never built my own synth, but just looking at all of these gorgeous contraptions tickles my brain in a certain way that makes me want to include it here

6 — Missile Command with a twist: this one's included because I thought it was genuis, Dan Luu built a game of Missile Command where you quite literally a fight for survival — the objective is to protect the game state that sits visualized at the bottom of the game screen, if damaged it makes parts of the game defect and can even render it unplayable.

7 — SVG ASCII Logo Generator: to cap off, Yoko Li built this neat little command line tool that lets you print text as ASCII art to the terminal and simultaneously exports them as SVGs to feed into your plotter or laser cutter.

Dev & Web Tech

1 — How to Write Blog Posts that Developers Read: one of the hardest things to figure out when you're just getting started with your blog, is finding topics to write about — topics that you have an opinion on, and that are relevant to a specific group of people that could potentially become your audience.

Michael Lynch writes about how to write dev blog posts that actually reach people, and some of the pitfalls to avoid:

2 — UI Algorithms: A Tiny Undo Stack: Julik Tarkhanov writes about how to program an undo stack in JavaScript — a feature in many UIs letting you undo and redo actions you've performed.

A simple approach to achieve an undo stack involves storing actions in an array and then keeping track of them with a pointer. Julik points out that keeping track of the pointer is cumbersome, and proposes a more sensible dual-stack method, where undo/redo actions simply migrate between the two arrays.

3 — A new way to draw separators in CSS: Kevin Babbitt and Patrick Brosset from the Microsoft Windows Blog wrote about a new way to draw separator lines in CSS and propose a new gap decorations solution where you can specify column and row rules to style separators in different layouts.

They write about it in more detail in an explainer on GitHub. For genart purposes I'm actually excited for this one; I recently attempted recreating one of my P5 sketches purely by using HTML and CSS to draw elements — I quickly realized that the positioning is quite cumbersome if you're drawing things simply using a border/fill hack; this could potentially be a solution to that.

4 — War Story: the hardest bug I ever debugged: sometimes you run into vexxing mystery bugs that are seemingly impossible to debug — Jacob Voytko recounts a non-deterministic, worst-case scenario bug that occurred during the development of Google Docs back in the early 2010s. After 2 days of grueling debugging, it turned out that the bug was deep within Chrome’s V8 JavaScript engine.

5 — A Love Letter to the CSV format: I wasn't aware that there's apparently some antagonism towards the CSV format; personally always thought it's pretty straightforward for my hobby purposes 🤷 But I guess that my sentiment towards CSV is just my uneducated opinion on the topic 😅

A little readme over on in the xan docs (a command line tool for processing csv files) reveals itself as a love letter to the format, highlighting its strengths and why its often criticized for the wrong reasons.

AI Corner

1 — Why are we still bullish on LLMs: I guess this one tracks back to the issue that AI is still not quite there yet. Sabine Hossenfelder singles out a very particular use-case here, and generalizes her sentiment to LLMs at large, which I might not entirely agree with. Finding and extracting relevant references sounds like a task for an agent that's specialized for it, like the Deep Research GPT agent which I think works decently enough.

LLMs are great for automating a lot of the tedious/mundane/crappy tasks — like for instance, I'm really happy I don't have to write data parsing python scripts from scratch anymore — now I can just prompt them into existence. Obviously, for anything slightly more complicated, that involves some sort of creative nuance, you'll find that LLMs quickly fall short.

2 — LLM Agents are simply Graph: LLM agents are simply thinking loops modeled as graphs: each node of the graph is either a particular action that the LLM is allowed to perform, or a prompt that updates the current state.

Currently there's an explosion of LLM agnostic frameworks (meaning you can plug in the LLM of your choice) to build these kinds of agents, like Pocket Flow that's advertised through this post. Some weeks ago I played around a bit with LangGraph, but I found it quite overkill for my little experimental projects — glancing over the docs, Pocket Flow seems like a much more accessible alternative. This lovely little tutorial breaks down the basics of it.

Music for Coding

It's a big shame that this EP is only 15 minutes long — in jazz is for ordinary people, berlioz blends jazzy melodies with deep house grooves in a really seamless manner. Perfect way to start your Monday morning I'd say:

And that's a wrap — hope you've enjoyed this week's curated assortment of genart and tech shenanigans!

Now that you find yourself at the end of this Newsletter, consider forwarding it to some of your friends, or sharing it on the world wide webs—more subscribers means that I get more internet points, which in turn allows me to do more internet things!

Otherwise come and say hi over on TwiX, Mastodon, or Bluesky and since we've also got a Discord now, let me shamelessly plug it here again. If you've read this far, thanks a million! And in case you're still hungry for more generative art things, you can check out last week's issue of the newsletter here:

You can also find a backlog of all previous issues here:

Cheers, happy coding, and again, hope that you have a fantastic week! See you in the next one!

~ Gorilla Sun 🌸