Paul Bourke

You got it! By approximate category and in no particular order:

## MISCELLANEOUS

- [Low Tech Magazine](https://solar.lowtechmagazine.com), a solar-powered website showcasing the amazing low-tech things you can do with a little ingenuity,

- [Stephen Wolfram's Blog](https://writings.stephenwolfram.com) on math, compsci, and everything else,

- [Cool Macrophotography](https://www.barrywebbimages.co.uk/Images/Macro/Slime-Moulds-Myxomycetes) for amazing pictures of tiny things (WARNING: Time Sink!),

## COMPUTER SCIENCE

- [While-True-Do](https://blog.while-true-do.io) has lots of stuff on Linux administration and self-hosting,

- [Backend Banter](https://www.backendbanter.fm) for a great podcast on backend development,

- [Two Wrongs](https://two-wrongs.com) for statistics and functional programming,

- [Math ∩ Programming](https://www.jeremykun.com/) where math and programming intersect! Written by a Googler...

- [Paul Bourke's site](https://paulbourke.net/) where you can get happily lost exploring old pages on every topic CS touches,

- [Jason Punyon's blog](https://jasonpunyon.com) for some fun algorithms and things,

- [Yossi Kreinin's blog](https://yosefk.com/blog) for C, Python, and plenty of non-technical topics,

- [Adrian Sampson's academic blog](https://www.cs.cornell.edu/~asampson/blog) for an academic's perspective,

- [Cool polyhedra viewer project](https://georgehart.com/virtual-polyhedra/vp.html) if you like geometry,

- [Another academic blog on…

I was very fortunate. This is the machine on which I originally learned OpenGL. It was an undergrad lab job where I was paid $5/hour to eventually write http://paulbourke.net/geometry/polygonise/marchingsource.cpp But, in order to do that I had to learn how to 3D at all.

The most fun I had with the machine was playing GlQuake 1 at 1280x1024 on a T1 line and bragging about it on the chat where everyone thought I was lying. Of course, a year later the 3DFX Voodoo 1 would come out and deliver approximately 1/4 the fill rate for 1/1000 the price.

Besides that, it was a fine machine. Lots of cores that I didn’t know how to utilize. Occasional bugs in the OpenGL implementation that might have been me accidentally triggering edge cases. Command line compiles, gdb, lots of core dumps.

SGI really lost it’s way after this. Years later they would be showing at SIGGRAPH with multi-wall-sized displays, but without the programmable shading that would be all the rage not just right then, but for the next two decades... They went so far as to publish papers showing that with hundreds of passes and temporary buffers using fixed-function shading, you could eventually get mostly the same results as the new-fangled programmable BS...

The brilliant engineers of SGI soon moved on to become founding members of Nvidia, ATI, Imagination and other graphics tech companies.

Didn't have much time to comment earlier, so an addendum.

The intro gene was the first time I had seen real-time metaballs. The implementation, and AFAIK all real-time metaballs in the demo scene at the time, relied on the Marching Cubes[1] algorithm, detailed by Paul Bourke here[2].

At the time the algorithm was patented, though up here in the Scandinavia that was not something that would hold back some teens. You can see the characteristic artifacts of the Marching Cubes algorithm in most demos.

In general metaballs is just one example of using isosurfaces for rendering[3]. Other typical applications is in visualizing partial differential equations, for example computational fluid dynamics. Often it's easier to formulate equations which govern the volume rather than the surface, and you use an isosurface technique to extract the surface you're after.

A point echo of Fudge told me was that a metaball doesn't have to have a strictly positive influence, you could have one which has a negative influence. I think this is what's going on with the red metaball scene in the gene intro.

Nice video, was fun to learn the origins of one of my beloved demo effects.

[1]: https://en.wikipedia.org/wiki/Marching_cubes

[2]: https://paulbourke.net/geometry/polygonise/

[3]: https://en.wikipedia.org/wiki/Isosurface

Historically, Pixar's RenderMan defaulted to a 2x2 Gaussian filter [1], and from what I can see, that hasn't changed [2].

Essentially it uses a truncated isotropic (non-separable) Gaussian defined by exp(-2.0 * (x*x + y*y)) with a 2x2 pixel support [3], which is slightly soft and completely avoids ringing.

Gaussian also plays very nicely with filtered importance sampling [4] since it has no negative lobes.

(Though I remember a number of studios using RenderMan preferring filters with a bit of sharpening.)

[1] https://paulbourke.net/dataformats/rib/RISpec3_2.pdf#page=40

[2] https://rmanwiki-26.pixar.com/space/REN26/19661819/Filtering

[3] https://paulbourke.net/dataformats/rib/RISpec3_2.pdf#page=207

[4] https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=d5d120ae2c47e38fc4a2d379cfcf9953f5e23ada

I'm going to suggest Paul Bourke's "Fractals, Chaos, Self-Similarity" website, because I often go there to get inspiration and code snippets - http://www.paulbourke.net/fractals/

Somebody else has already mentioned the excellent @beesandbombs on Twitter. I sometimes spend too much time trying to work out how Dave achieves a particular effect - https://twitter.com/beesandbombs

If you're going to be drawing into the browser using the canvas element, I suggest you check out the Slaylines canvas comparison test page. There's a link to the GitHub repo which includes links to all the canvas libraries demoed there. Try out several libraries, settle for the ones which fit easiest into your preferred working style - https://benchmarks.slaylines.io/

I have no idea honestly...

One pointer that might be worth exploring, which is not quite L-Systems but might be related is Fractal Compression. I've read that there are algorithms to compress images into a "closest" IFS – iterated function system.

https://en.wikipedia.org/wiki/Fractal_compression

Maybe one could come up with a way of going from an image via fractal compression to an IFS which could then be used as the basis for an L-system?

Most of the L-Systems that are on this site are from
Paul Bourke – http://paulbourke.net/fractals/lsys/

Which is a really awesome resource!