Mine has to be this continuous version that makes pretty crazy looking creatures: https://chakazul.github.io/Lenia/JavaScript/Lenia.html.
It was also featured on HN:
And it occurs to me, a blank sheet of paper qualifies as the Game Of Life simulating the Game Of Life.
https://adventofcode.com/2024/day/21
It really makes you think about this; interaction between levels in a simulation.
What are other Great Wonders of software?
- cryptography in general
- data compression
- a lot of DSP stuff is pretty magical in it's various applications - digital filtering, modulation/demodulation, recovery of weak signals in noisy environments, beam-forming etc
There's a lot of really amazing, largely mathematical, foundation work that we now tend to take for granted and without which we'd be back in the relative dark ages.
Within 30 seconds, it crashed my 2016 MacBook Pro (maybe overloaded the CPU + the failing battery? It's a feeble machine).
After the Mac's version of the BSD, Mac helpfully restored all of my windows (I have that setting turned off), and there it was again, happily Game Of Lifing in the background. Shut it down just as the fans were spinning up again.
Btw, can the game of life (at least in theory) simulate chaotic systems like a double pendulum?
Correct me if I am wrong.
life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +⌿ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}
Conway's Game Of Life in APL (2009) [video] - https://news.ycombinator.com/item?id=22845249 - April 2020 (13 comments)
Conway's Game of Life in One Line of APL (2007) - https://news.ycombinator.com/item?id=10366441 - Oct 2015 (12 comments)
Conway's Game Of Life in APL - https://news.ycombinator.com/item?id=7492585 - March 2014 (2 comments)
Conway's Game Of Life written in one line of APL - https://news.ycombinator.com/item?id=4642628 - Oct 2012 (2 comments)
Conway's Game of Life in APL - https://news.ycombinator.com/item?id=4611015 - Oct 2012 (1 comment)
Conway's Game Of Life in one line of APL - https://news.ycombinator.com/item?id=3840273 - April 2012 (2 comments)
Conway's Game of Life in one line of APL - https://news.ycombinator.com/item?id=2547655 - May 2011 (22 comments)
Conway's Game of Life in one line of APL - https://news.ycombinator.com/item?id=1499630 - July 2010 (1 comment)
Conway's Game Of Life in one line of APL - https://news.ycombinator.com/item?id=1041500 - Jan 2010 (31 comments)
Game of Life implemented in 5 minutes using APL (amazing video) - https://news.ycombinator.com/item?id=451951 - Jan 2009 (1 comment)
Conway's Game of Life in one line of APL - https://news.ycombinator.com/item?id=451923 - Jan 2009 (1 comment)
Conway's Game of Life in one line of APL - https://news.ycombinator.com/item?id=204042 - May 2008 (4 comments)
---
Honorable mention:
Conway's Game of Life in APL in Forth - https://news.ycombinator.com/item?id=31537648 - May 2022 (25 comments)
life←{≢⍸⍵}⌺3 3∊¨3+0,¨⊢https://en.wikipedia.org/wiki/Hashlife
My personal favorite has to be the one I made in x86 assembly ~30 years ago. I didn't know about hash life at the time, but still, it ran pretty fast. I seem to remember I used page flipping and moved the start of video memory each iteration. Or something like that.
(defn neighbors [[x y]] #{[(dec x) (dec y)] [(dec x) y] [(dec x) (inc y)] [ x (dec y)] [ x (inc y)] [(inc x) (dec y)] [(inc x) y] [(inc x) (inc y)]})
(defn count-neighbors [world cell] (count (set/intersection (neighbors cell) world)))
(def rules #{[true 2] [true 3] [false 3]})
(defn live [world cell] (contains? rules [(contains? world cell) (count-neighbors world cell)]))
(defn evolve [world] (into #{} (filter #(live world %) (reduce set/union (map neighbors world)))))
Full source: https://github.com/twpayne/life/blob/master/clojure/src/life...
https://colab.research.google.com/github/norvig/pytudes/blob...
Description: https://www.phatcode.net/res/224/files/html/ch18/18-01.html
Code: https://www.phatcode.net/res/224/files/html/ch18/18-03.html
Hashlife is far superior so while Qlife was interesting it wasn't the best implementation.
Previously: https://news.ycombinator.com/item?id=39799755
(Ope, ninja'd)
https://news.ycombinator.com/item?id=42806736
DonHopkins 20 days ago | parent | context | favorite | on: Psychedelic Graphics 0: Introduction
Here's a classic video by Rudy Rucker demonstrating his CALab product that he made with John Walker at Autodesk:
https://www.youtube.com/watch?v=lyZUzakG3bE
At 24:28 he shows a running Belousov–Zhabotinsky reaction mapped onto a 3d model's texture:
https://youtu.be/lyZUzakG3bE?t=1468
I wrote about it in the discussion of John Walker passing away, and Josh Gordon, who worked on Chaos at Autodesk, joined the discussion:
https://news.ycombinator.com/item?id=39300605
>DonHopkins 11 months ago | parent | context | favorite | on: John Walker, founder of Autodesk, has died
>I really love and was deeply inspired by the great work that John Walker did with Rudy Rucker on cellular automata, starting with Autodesk's product CelLab, then James Gleick's CHAOS -- The Software, Rudy's Artificial Life Lab, John's Home Planet, then later the JavaScript version WebCA, and lots of extensive documentation and historical information on his web page. CelLab:
https://www.fourmilab.ch/cellab/
https://www.fourmilab.ch/cellab/classic/
https://www.fourmilab.ch/homeplanet/
https://www.rudyrucker.com/oldhomepage/cellab.htm
[...]
>josh_gordon 11 months ago | prev [–]
>I'm amazed that my beloved CHAOS still runs beautifully on emulators like DOSbox. It was the last programming project where I could completely roll my own interface - and maybe my last really fun one.
Here's some stuff I did that was inspired by Rudy Rucker and John Walker's work, as well as Tommaso Toffoli and Norm Margolus's wonderful book, "Cellular Automata Machines: A New Environment for Modeling":
https://news.ycombinator.com/item?id=37035627
by DonHopkins on Aug 7, 2023 | parent | context | favorite | on: My history with Forth and stack machines (2010)
>"Cellular Automata Machines: A New Environment for Modeling" is one of my favorite books of all time! It shows lots of peculiarly indented Forth code.
https://donhopkins.com/home/cam-book.pdf
>CAM6 Simulator Demo:
https://www.youtube.com/watch?v=LyLMHxRNuck
>Forth source code for CAM-6 hardware:
https://donhopkins.com/home/code/tomt-cam-forth-scr.txt
https://donhopkins.com/home/code/tomt-users-forth-scr.txt
And a couple more recent videos to music using the SimCity/Micropolis tile set and WebGL tile engine to display cells:
SimCity Tile Sets Space Inventory Cellular Automata Chill Resolve 1
https://www.youtube.com/watch?v=319i7slXcbI
I performed it in real time in response to the music (see the demo below to try it yourself), and there's a particularly vivid excursion that starts here:
https://youtu.be/319i7slXcbI?t=314
The following longer demo starts out with an homage to "Powers of 10", and is focused on SimCity, but shows how you can switch between simulators with different rules and parameters, like setting rings of fire with the heat diffusion cellular automata, then switching to the city simulator to watch it all burn as the fires spread out and leave ashes behind, then switching back to another CA rule to zap it back into another totally different pattern (you can see a trail of destruction left by not-Godzilla at 0:50 while the city simulator is running).
I had to fix some bugs in the original SimCity code so it didn't crash when presented with the arbitrarily scrambled tile arrangements that the CA handed it -- think of it as fuzz testing; due to the sequential groups of 9 tiles for 3x3 zones, and the consecutive arrangements of different zone type and growth states, the smoothing heat diffusion creates all these smeared out concentric rings of zones for the city simulator to animate and simulate, like rings of water, looping animations of fire, permutations of roads and traffic density, rippling smokestacks, spinning radars, burbling fountains, an explosion animation that ends in ash, etc.
Chaim Gingold's "SimCity Reverse Diagrams" visually describes the SimCity tiles, simulator, data models, etc:
https://smalltalkzoo.thechm.org/users/Dan/uploads/SimCityRev...
Micropolis Web Space Inventory Cellular Automata Music 1:
https://www.youtube.com/watch?v=BBVyCpmVQew
You can play with it here. Click the "X" in the upper left corner to get rid of the about box, use the space bar to toggle between SimCity and Cellular Automata mode, the letters to switch between cities, + and - switch between tile sets (the original SimCity monochrome tiles are especially nice for cleansing the palette between blasts of psychedelic skittles rainbows, and the medieval theme includes an animated retro lores 8 bit pixel art knight on a horse), the digits to control the speed, and 0 toggles pause. (It's nice to slow down and watch close up, actually!):
As you can see it's really fun to play with to music and cannabis, but if you're going to use any harder stuff I recommend you get used to it first and have a baby sitter with you. Actually the whole point of my working on this for decades is so that you don't need the harder stuff, and you can put it on pause when you mom calls in the middle of your trip and you have to snap back to coherency, and close the tab when you've had enough.
DonHopkins 20 days ago [–]
There's so much about it that I love, but my favorite part of Rudy's CALab demo is the "Office of the Future" and 1-800 number at the end:
I'm not saying this is mechanically interesting (it's just a simple filter) or will change your life or anything, but I do remember spending a lot of time tinkering with and watching that particular implementation.
Best looking? Lowest resource utilization? Smallest code size? Fastest? Largest playing field? etc.
https://c0stya.github.io/articles/game_of_life.html
### The code ###
import numpy as np
from scipy.signal import convolve2d
field = np.random.randint(0, 2, size=(100, 100)) # 100x100 field size
kernel = np.ones((3, 3))
for i in range(1000): # 1000 steps
new_field = convolve2d(field, kernel, mode="same")
field = (new_field == 3) + (new_field == 4) * fieldMaybe someone on HN remembers it and can tell me its name?
CPU are very different these days, but the process he goes through is essentially unchanged.
Here's the game of life running in the game of life: https://youtu.be/xP5-iIeKXE8?si=7NslTsVlW0USjQFw - that one uses Golly.
(In case it's not super clear, I'm kinda jokin' here...)
https://chatgpt.com/canvas/shared/67a71a9f57bc819185cade8f59...
At the time I was doing a lot of simulation work, so methods for bridging discrete and continuous domains were interesting.
https://latedev.wordpress.com/2011/06/25/a-poker-chip-comput...
The most mind blowing algorithm has to be hashlife though. Well worth studying for those aha moments.
I like control-shift-r to refresh the page.
(may include SAT solvers and traces of black magic)
https://x.com/deadfoxygrandpa/status/1819204922271060440
screenshot of it here: https://i.imgur.com/Iq9XXi4.jpeg
I believe it implements Bill Gosper's hashlife quadtree algorithm (already mentioned elsewhere in the comments here).
Xlife is unbelievably fast.
https://en.wikipedia.org/wiki/Flag_of_Belarus#/media/File:Be...
Edit: not really. But what a wasted opportunity. Come on, State Committee for Standardization of the Republic of Belarus, what are you doing all day?
Still a little bit curious what it does look like though...
The edge condition optimization eliminates the eight conditional branches in the inner loop checking for edge conditions, and the memory optimization eliminates six out of nine loads per cell in the inner loop.
Here are the comments about optimization from the CAM6 code:
https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...
// Optimization Techniques
//
// Extra copying is eliminated by swapping between two cell buffers,
// one for the past and the other for the future. After applying the
// rule, the past cell buffer becomes the future, and the future
// becomes the past. It's necessary to have two buffers, because
// you can't apply cellular automata in-place in one buffer, since
// you would stomp on your past neighbors whose future you just
// computed, since the neighbors above and to the left would be
// from the future instead of the past.
//
// Edge conditions eliminated from inner loop by making cell buffers
// two cells wider and taller, and wrapping edges around to the
// extra edge cells before applying rule, so the inner loop does not
// have to check for edge conditions to wrap the cells, and other
// edge treatments can be applied besides wrapping, like clamping or
// reflecting.
//
// Index table lookup based rules, that allow you to define rules in
// JavaScript in terms of their neighbors, which are then applied to
// every possible combination of neighbor states, to generate a
// lookup table that is used by the neighborhood to evaluate the
// rule without running a lot of JavaScript code. This is how the
// CAM6 hardware works, and the rule tables are compatible with its
// rule tables. The hardware concatenates the bits of the neighbors
// into an index that is used to look up the next cell value in the
// lookup table. It's not clear if this is actually any faster in
// software, because it's a software emulation of a hardware
// optimization, and depends a lot on the rule and the code that
// implements it, but at least it lets you write your rule
// definitions clearly without worrying about efficiency, and also
// translate the Forth rules defined in the Cellular Automata
// Machine to JavaScript (or use old rule tables generated by Forth
// if you can find them), and run them in the simulator.
//
// JavaScript code templates for neighborhood functions, rules,
// tools, colormap generators, etc, with slots that let rules inject
// custom code into the inner loop, disable unnecessary code,
// calculate parameters, inline constants, etc. This enables
// neighborhoods to be much more general purpose, and not only
// deeply parametrizable but also arbitrarily extensible,
// supporting complex rule definition, as well as real time analysis
// and event reporting (like the cell value histogram). And it also
// enabled users to play around with writing their own rules and
// modifying and extending existing ones, and they will still run
// efficiently.
Here's a video I recoded of playing around with that to music:
SimCity Micropolis Tile Sets Space Inventory Cellular Automata To Jerry Martin's Chill Resolve:
https://www.youtube.com/watch?v=319i7slXcbI
The musical style of "Chill Resolve" may ring a bell, because Jerry Martin is the musician who composed the music for The Sims and SimCity 2000 and many other Maxis games, and he has some more great free music on his web site:
And here is a longer demo that explores some of the more subtle effects, starting out with an homage to "Powers of 10", with some more great music by Juho Hietala, Blamstrain:
Micropolis Web Space Inventory Cellular Automata Music 1:
https://www.youtube.com/watch?v=BBVyCpmVQew
The space bar randomly toggles between two CA rules (one heat diffusion with randomized parameters, and one combination of Anneal, Life, and Brain's Brain).
Here's the code that implements the cellular automata running in SimCity's 16 bit tile memory. I originally wrote it a long time ago in C on a 68k Sun 3 Workstation, so it uses some terribly ugly C macrology. This code is written in C++ and compiled to WebAssembly, and is adapted to deal with SimCity's in-memory tile layout that doesn't have an gutter around it, so it performs an extra copy, so isn't optimal. But if you were implementing a pure optimized cellular automata not duct-taped and bailing-wired into an existing game, you could just use two buffers of the same size with gutters around them, and swap their pointers each iteration, to eliminate the extra copy of all the cells, of course:
https://github.com/SimHacker/MicropolisCore/blob/main/Microp...
The heatWrap parameter switches between different edge condition wrapping/clamping modes applied to the gutters, defaulting to 4, which wraps the edges around like a torus.
You can play with the CAM6 emulator here, which is written in JavaScript. Click the square in the upper right corner to show the controls, and switch the rule to Life, but it has many other rules too:
https://donhopkins.com/home/CAM6
Here's the source code of a hard-coded Life rule (with some bonus features like running a heat diffusion in parallel in the upper bits, and rotating the scanning order to cancel out the heat diffusion dithering artifacts):
https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...
There is another lookup-table based implementation of Life that is compatible with the way the CAM6 hardware works. It uses a Moore neighborhood. This code snippet is not run in the inner loop, it's run over all possible input configurations to generate a lookup table that is used by the generic Moore neighborhood code. So it doesn't need to be optimized because it runs outside of the inner loop:
https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...
// ruleFunction_Moore_life computes the life rule Moore
// neighborhood lookup table.
function ruleFunction_Moore_life(ruleDict, state) {
var sum8 =
ruleUtil_Moore_sum8_0(state);
if (state.c0) {
return (((sum8 == 2) ||
(sum8 == 3))
? 1 : 0);
} else {
return ((sum8 == 3)
? 1 : 0);
}
}
https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...
Moore neighborhood explained:
https://en.wikipedia.org/wiki/Moore_neighborhood
Here's an in-depth technical demo that I recorded for Norman Margolus explaining how it was inspired by his book and how it works:
https://www.youtube.com/watch?v=LyLMHxRNuck
Here's the technique for reducing the number of memory loads per cell in the inner loop from 9 to 3. For each row you "prime the pump" by loading the right two columns of a 3x3 window, and then for each cell you scroll the window to the left and load the three incoming cells.
for (var cellY = 0;
cellY < height;
cellY++) {
// Load the right two columns of the 3x3 window.
n = cells[cellIndex - nextCol - nextRow]; ne = cells[cellIndex - nextRow];
c = cells[cellIndex - nextCol ]; e = cells[cellIndex ];
s = cells[cellIndex - nextCol + nextRow]; se = cells[cellIndex + nextRow];
for (var cellX = 0;
cellX < width;
cellX++) {
// Scroll the 3x3 window to the right, scrolling the middle and right
// columns to the left, then scooping up three new cells from the right
// leading edge.
nw = n; n = ne; ne = cells[cellIndex + nextCol - nextRow];
w = c; c = e; e = cells[cellIndex + nextCol ];
sw = s; s = se; se = cells[cellIndex + nextCol + nextRow];
https://news.ycombinator.com/item?id=40701784
DonHopkins 8 months ago | parent | next [–]
Amazing!
Decades ago, Will Wright suggested to me a nice optimization for cellular automata and convolution filters that lets you eliminate the bounds checks in the inner loop, which I implemented in my CAM6 cellular automata machine simulator:
Eliminate the edge conditions (and conditionals in the inner loop) by making a "gutter" of one extra pixel (or however many pixels your neighborhood extents out) around all the edges of the bitmap (i.e. increase the width and height by 2, then inset x and y by 1), then before processing each frame, copy the appropriate edges into the corresponding gutters (wrapping or clamping), then iterate over the pixels just inside the gutters, so you don't have to perform any bounds checks.
https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...
[...see Optimization Techniques comments above...]
https://webglfundamentals.org/webgl/webgl-3d-textures-repeat...
But on old school consoles you have have to use software tricks like that instead of relying on the hardware.
And of course if you're using power of two sized bitmaps you can just mask the coordinates, which is practically free.
You could fix SimCity to use that trick, but it would make the code more complex, and it's probably not worth it on anything but really old hardware like the C64 or Sega Dreamcast.