Gorilla Newsletter 101

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

This is the 101st 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

What's more is that Etienne actually also introduces a 15th sensing parameter, integrates color gradients (comparing current vs. delayed trails), particle inertia, and an interactive “pen” that spatially blends parameter sets under the cursor.

We've previously talked about the topic in issue #68 of the newsletter, where Deniz Bicer had created a really cool interactive introduction.

Physarum sims are essentially particle-based algos that recreate the behavior of slime mold s, as well as ant colonies, in a digital setting. For context, I'll quote what I previously wrote:

Originally described by Jeff Jones in his 2010 paper titled "Characteristics of pattern formation and evolution in approximations of Physarum transport networks", the algorithm was later brought to popular attention in the generative art/creative coding space by Sage Jenson (@mxsage), with an iconic blog post of his published in 2019.

If you're looking for a more beginner friendly intro to the algorithm, you should definitely check out Patt Vira's tutorial.

Software rasterizers are essentially a CPU-based renderer that can render primitives to the screen by determining which pixels need to be turned on, and what color they should be.

So the entire GPU shader-shebang, like scan conversion, per‑vertex attribute interpolation (color, texture coordinates, and normals), performing depth tests to resolve visibility, and running fragment shaders to compute final pixel color, but simply on the CPU. Lague also covers some tricks on how to create a relatively performant pipeline:

Coincidentally, this week I also came across a tutorial series back from 2022, written by Kristoffer Dyrkorn, similarly showing us how to create a triangle rasterizer that's fast and precise:

A recent article by Archivist uncovers this story, linking two of the first digital artifacts on the Namecoin chain (the first altcoin and second blockchain after Bitcoin launched on April 18, 2011 as a fork of Bitcoin’s code), back to Ryan Bell.

Just last week Ryan Bell has also published a new project on fxhash—titled Duality of Zed, his project charts wholly uncovered fractal territory. The work explores two fractal formulas in particular: ln(-z)/ln(z) and ln(z)/(z+1), resulting in some really crazy patterns, that only get more intricate as they are evolved by collectors 👇

These are forms that emerge naturally from pure logic through concise yet powerful expressions like ln(-z)/ln(z) or ln(z)/(z+1). Using computers as microscopes, viewers can explore these patterns across a zoom range spanning more than 25 orders of magnitude, from macroscopic scales down to microscopic depths, where individual pixels represent regions smaller than subatomic particles.

Implementing the initial version with P5, I already knew how to optimize particle collisions via spatial hashing (a grid lookup), but then I quickly realized that rendering was a performance bottleneck.

With P5 you essentially draw shapes one after the other to the canvas—each taking its own turn. But why not render all of them to the screen simultaneously? This can be done when you use a GPU accelerated renderer like Three.js, there you can batch draw calls if they all use the same texture and material.

A new codrops article by Matias Gonzalez Fernandez shows how to use instancing to achieve simultaneous rendering of multiple similar 3D objects in the same scene, using React Three Fiber—which essentially is the React version of Three.js:

I couldn't find more information about the project at this, except for the trailer shared in the Twitter post and the description on the luma invite link:

Mote is an interactive ecosystem simulation composed of hundreds of thousands of organisms. It integrates elements from both games and research to create a sandbox for computational biology, machine learning, and physics. It uses a custom GPU-based physics engine to model the interactions of many simple behaviors at a massive scale, producing a wide range of fascinating emergent phenomena.

The talk will be up on the Recurse Center's YouTube channel afterwards!

Improvisational Machines was inspired by the Haute Cuture Robotics choreography previously presented the 2025 Paris Fashion show, where she had to rapidly figure out a setup over the course of a two week sprint, where the team could only finalize the creative decisions the day before the show.

The page on Creative Applications explains some of what was covered by the workshop:

I'm not certain if Theobald Beyer is still active on social media, or if the list is still being maintained, but I found that is the same person that's behind the famous Hydraulic Erosion paper from the Technical University in Munich, on which the equally famous Sebastian Lague coding adventure is based:

This makes me want to create my own link aggregator page—I think I've accumulated quite a few resources at this point through the newsletter!

Dev & Web Tech

With 8717 one respondents chiming in, on questions about workplace issues, health, and hobbies. It's a really interesting, and likely relatable one for many devs out there—for instance the top 3 workplace problems that participants stated were bad management, burnout, and work-life balance issues.

There's also four insightful statements packaged along with the survey results, about workplace discrimination, the importance of bringing in new devs, and the urgence of software companies focusing on the well-being of their employees. Anjana Vakil writes:

As software developers, we tend to think that what we do is about programming, performance, and pull requests. But ultimately, software is really about people. And people are complicated.

One statement is from Josh Comeau, who was also quick to create a full analysis of the results that he sent out in his newsletter:

[...] the biggest thing that stood out to me is that while things aren’t as good as they used to be, they’re also not as bad as I expected.

Highly recommend subscribing to him!

Many of his points resonated with me, and are things I have already experience to some extent both throughout working on my own projects, and during actually work—particularly this segment:

If you're okay with things moving slowly, they will. Aggressive deadlines expose hidden complexity. They force conversations about what really matters. [...] If there's no date, it might take 3 months. But if you set a date of 2 weeks and it actually takes 1 month, great, you just shipped a first version 3x faster.

Deadlines can be a blessing and a curse, but if you want to make things move forward, you should always set a deadline. It's often the only way to figure out what works, what doesn't, and where the problems are actually at. But that's just one of the points he brings up throughout.

When you get into app development, this is usually first thing you learn: signing up new users and then letting them log in—which is provided out of the box by DBaaS. If you're like me, you're happy that this is provided as is, without actually having to learn how it works, or needing to build it yourself. Jeff Escalante wrote a break-down of the Open Authorization protocol and how it works in detail:

Usually I try to add something smart to the article, but this one's entirely above my paygrade, so... 🤷 enjoy the article!

Justin Fagnani argues that the time is right to build a declarative templating API directly into the DOM; with modern frameworks we've already converged on similar syntax and semantics, and figured out best-practices—using tagged template literals, reactive primitives like signals, and efficient update strategies such as template identity. In essence, nothing stands in the way of having a small, secure, performant templating primitive.

And ultimately this would benefit everyone involved: smaller downloads and faster loads for users, no extra dependency management for devs, and framework authors could build on a standardized foundation instead of re‑inventing the wheel.

Links, Resources, and Humans of Note - Infrequently Noted

Alex Russell on browsers, standards, and the process of progress.

Alex RussellAlex Russell

AI Corner

1 — Diffusion Models the next Frontier of AAA Game Development: Kyle Kukshtel argues that for decades console generations have relied on raw GPU power to chase ever‑shinier graphics—only to hit a plateau in photorealism. New games that require more performant devices to run on, rarely use this performance boost to actually do more in terms of gameplay.

Engines like Unreal now ship “80% of AAA fidelity” out of the box, commoditizing graphical spectacle, and squeeze premium studios that still pour $500–900 million into marginal visual gains. Meanwhile, players have come to realize that good graphics don't really make a good game, and generally gravitate toward lean, honest experiences rather than increasingly glossy but hollow blockbusters.

Kyle sees us at a new frontier, where integrated, graphics-generating diffusion models pose themselves a threat to triple AAA game makers. While we are still far out from this, his article speculates about how this changes the playing field for game creators:

Check out issue #71, where we talked about GameNGen, a diffusion model that runs DOOM and is capable of responding to user inputs.

Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity

METR10 July 2025

Developers were assigned a mix of bug fixes, new features, and refactors and randomly told to either use AI (mainly Cursor Pro with Claude) or go solo. Surprisingly, when AI was on the table, writers took about 19% longer to finish tasks than without it, despite expecting a 24% speedup. Even after working with AI and slowing down, most still believed the tools had sped them up by around 20%.

Unsurprisingly, most of the slowdown stemmer from the extra overhead of crafting prompts, reviewing AI suggestions, and integrating them into the existing codebase. You can read the full paper here.

Music for Coding

This week I discovered the music of Kowloon—a musician and filmmaker from Los Angeles. His debut album 'Come Over' was written and recorded in its entirety in his home studio in the industrial outskirts of the city.

Kowloon fuses vintage synths, drum machines, and bubbling bass lines—culminating in very danceable love songs. The lyrical content of the soft vocals however contrasts with the lightheartedness of the music itself however, and aims to convey a sense of "digital malaise".

You can listen to entire album on his YouTube channel here 👇

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 web—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 🌸