CAM6

ile of them to hand out to tricker-treaters and religious zealots who knock on my door, as brain candy to set them on a better path). He's also given me permission to make interactive versions of any of those chapters, and he said that his favorites were the physical simulations, because they have something to say about nature and physics. That's definitely on my TODO list! I'd really like to do a "KidPix" kind of cellular automata playground, like Rudy Rucker and John Walker did with Autodesk CALab. There's some great stuff from that online, including a web based version of CALab and a fieldbook of many rules in the manual: https://www.rudyrucker.com/blog/2023/12/07/the-roaring-twent... https://scanalyst.fourmilab.ch/t/rudy-rucker-and-john-walker... https://www.fourmilab.ch/cellab/ https://www.fourmilab.ch/cellab/manual/ This is one of my favorites, ECOLIBRA, which I call ECO, and used for SimCity DRM as well as demonstrated in those videos. Rudy came up with it, as an excercise in composing multiple CA rules by layering and multiplexing: there is one layer of "ANNEAL" that defines whether each cell is water or land, and in land it runs "LIFE" and in water it runs "BRIAN'S BRAIN" (named after Brian Silverman, who did not actually name it after his own brain, that was somebody else attributing it to that part of his anatomy). https://www.fourmilab.ch/cellab/manual/rules.html#EcoLiBra ANNEAL (Vote rule + tie breaker flip): https://youtu.be/lyZUzakG3bE?t=534 LIFE: https://youtu.be/lyZUzakG3bE?t=572 BRAIN: https://youtu.be/lyZUzakG3bE?t=588 ECOLIBRA: https://youtu.be/lyZUzakG3bE?t=612 >This rule is a cross between Life and Brain. The basic idea is that the cells are divided between dark “sea” cells and light “land” cells. We run Brain in the sea, and on land we run not Life but AntiLife. All the land cells are normally firing cells, and the presence of an active AntiLife cell is signaled by having a land cell which is not firing. Full details on EcoLiBra are in the Cellular Automata Theory chapter. >The name EcoLiBra suggests 1) an ecology of Life and Brain, 2) a balanced situation (equilibrium), and 3) the human intestinal bacteria Escherichia coli, known as E. coli for short. The third connection is perhaps a bit unsavory, but remember that E. coli cells are in fact the favorite “guinea pigs” for present day gene splicing experiments. As one of the goals of CelLab is to promote the development of artificial life, the designer gene connection is entirely appropriate. I've given EcoLiBra a nice, symmetric start pattern, but it also does fine if you use the Bit Plane Editor to randomize all bit planes. The "ECO" version in my simulator actually runs "DEATH" aka "ANTI-LIFE", the one's complement of "LIFE", so that the cells of LIFE and BRAIN along the shores stimulate each other more and spawn lots of life onto land and brain into the sea, due to their "foamier" interactions along the coast. I also took Rudy's idea of layering CA rules another 5 steps and ran a dithered heat diffusion in the upper 5 leftover high bits (and echo the 1 bit of life's history into the next higher bits so life and brain are both the same 2 bits of depth + 1 bit of anneal + 5 bits of heat), so the heat diffusion picks up "heat" that the life and brain particles emit, and they leave trippy trails and cause "global warming". Using CA to tell a metaphorical narrative of the organisms polluting their own environment. https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... (Yes it's unnecessariy complicated code, and don't get me started about why it rotates the scan order around every 4 frames -- suffice it to say it makes it look better, by canceling out the directional heat diffusion dithering artifacts from the serial scan order). More links here, and if you only look at one, be sure to check out Rudy's 1970's late night television style commercial with overdubbed 800 number. https://news.ycombinator.com/item?id=42806736 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: https://youtu.be/lyZUzakG3bE?t=2067

-scr.txt My compatible CA compiler and glue to the simulator written in C: cam.f.txt: https://donhopkins.com/home/code/cam.f.txt compile.f.txt: https://donhopkins.com/home/code/compile.f.txt An old version of the simulator written C, before I rewrote it in JavaScript: https://github.com/SimHacker/micropolis/tree/master/Micropol... The JavaScript CAM6 simulator: CAM6.js: https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...

effects. Eventually it was translated to // C++ and Python, and then more recently it has finally been // rewritten from the ground up in JavaScript. // The CAM6 hardware and Forth software for defining rules and // orchestrating simulations is thoroughly described in this wonderful // book by Tommaso Toffoli and Norman Margolus of MIT. // Cellular Automata Machines: A New Environment for Modeling // Published April 1987 by MIT Press. ISBN: 9780262200608. // https://mitpress.mit.edu/9780262526319/cellular-automata-machines/

// 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. You can play with the SimCity/Micropolis CA by disobeying the important safety warning about not opening up the Space Inventory, by pressing the space bar a few times: https://micropolisweb.com 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: https://boombamboom.com/ 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); } } There's some other rule compiler code that calls that function repeatedly over all possible permutations of neighbor states in ruleDict, to generate the lookup table, that's used by the Moore neighborhood (which itself also has some fancy optional features): 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]; Here's the explanation of the edge condition gutter optimizations that I posted recently: 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...] You can either wrap the cells into the gutter from the opposite edge like a torus, which makes nice seamlessly tileable patterns, or in the case of something like SimCity pollution diffusion, you can just clamp the pixels into the gutter along the same edge. Shaders have a way of wrapping and clamping and mirroring automatically (wrapping modes): 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.

sively parallel distributed "Think Globally, Act Locally" approach that also applies to so many other aspects of life. But by "life" I don't mean just the cellular automata rule "life"! Not to be all depressing like Marvin the Paranoid Android, but I happen to think "life" is overrated. ;) There are so many billions of other extremely interesting cellular automata rules besides "life" too, so don't stop once you get bored with life! ;) https://www.youtube.com/watch?v=CAA67a2-Klk For example, it's kind of like how the world wide web works: "Link Globally, Interact Locally": https://donhopkins.medium.com/scriptx-and-the-world-wide-web... It's also very useful for understanding other massively distributed locally interacting parallel systems, epidemiology, economics, morphogenesis (reaction-diffusion systems, like how a fertilized egg divides and specializes into an organism), GPU programming and optimization, neural networks and machine learning, information and chaos theory, and physics itself. I've discussed the book and the code I wrote based on it with Norm Margolus, one of the authors, and he mentioned that he really likes rules that are based on simulating physics, and also thinks reversible cellular automata rules are extremely important (and energy efficient in a big way, in how they relate to physics and thermodynamics). The book has interesting sections about physical simulations like spin glasses (Ising Spin model of the magnetic state of atoms of solid matter), and reversible billiard ball simulations (like deterministic reversible "smoke and mirrors" with clouds of moving particles bouncing off of pinball bumpers and each other). Spin Glass: https://en.wikipedia.org/wiki/Spin_glass >In condensed matter physics, a spin glass is a magnetic state characterized by randomness, besides cooperative behavior in freezing of spins at a temperature called 'freezing temperature' Tf. Magnetic spins are, roughly speaking, the orientation of the north and south magnetic poles in three-dimensional space. In ferromagnetic solids, component atoms' magnetic spins all align in the same direction. Spin glass when contrasted with a ferromagnet is defined as "disordered" magnetic state in which spins are aligned randomly or not with a regular pattern and the couplings too are random. Billiard Ball Computer: https://en.wikipedia.org/wiki/Billiard-ball_computer >A billiard-ball computer, a type of conservative logic circuit, is an idealized model of a reversible mechanical computer based on Newtonian dynamics, proposed in 1982 by Edward Fredkin and Tommaso Toffoli. Instead of using electronic signals like a conventional computer, it relies on the motion of spherical billiard balls in a friction-free environment made of buffers against which the balls bounce perfectly. It was devised to investigate the relation between computation and reversible processes in physics. https://en.wikipedia.org/wiki/Reversible_cellular_automaton >A reversible cellular automaton is a cellular automaton in which every configuration has a unique predecessor. That is, it is a regular grid of cells, each containing a state drawn from a finite set of states, with a rule for updating all cells simultaneously based on the states of their neighbors, such that the previous state of any cell before an update can be determined uniquely from the updated states of all the cells. The time-reversed dynamics of a reversible cellular automaton can always be described by another cellular automaton rule, possibly on a much larger neighborhood. >[...] Reversible cellular automata form a natural model of reversible computing, a technology that could lead to ultra-low-power computing devices. Quantum cellular automata, one way of performing computations using the principles of quantum mechanics, are often required to be reversible. Additionally, many problems in physical modeling, such as the motion of particles in an ideal gas or the Ising model of alignment of magnetic charges, are naturally reversible and can be simulated by reversible cellular automata. Also I've frequently written on HN about Dave Ackley's great work on Robust-First Computing and the Moveable Feast Machine, which I think is brilliant, and quite important in the extremely long term (which is coming sooner than we think). https://news.ycombinator.com/item?id=22304110 https://news.ycombinator.com/item?id=22300376 https://news.ycombinator.com/item?id=22303313

ing 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 right 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. // https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... // wrapCells wraps the cell edges. [...] You can either wrap the cells into the gutter from the opposite edge like a torus, which makes nice seamlessly tileable patterns, or in the case of something like SimCity pollution diffusion, you can just clamp the pixels into the gutter along the same edge. Shaders have a way of wrapping and clamping and mirroring automatically (wrapping modes): 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.

y Rudy Rucker Drawn by Gary Wells Modeled with AutoCAD Rendered by AutoShade Perpetrated by Kelvin R. Throop. In this rule, we only change the cells whose high bits are on. These cells are updated according to the TimeTun rule. http://www.technovelgy.com/ct/content.asp?Bnum=299 >Some looked humanoid, some looked like spiders, some looked like snakes ...All were covered with flickercladding, a microwired imipolex compound that could absorb and emit light. https://en.wikipedia.org/wiki/Wetware_(novel) >The plot goes disastrously awry, and a human corporation called ISDN retaliates against the boppers by infecting them with a genetically modified organism called chipmold. The artificial disease succeeds in killing off the boppers, but when it infects the boppers' outer coating, a kind of smart plastic known as flickercladding, it creates a new race of intelligent symbiotes known as moldies — thus fulfilling Berenice's dream of an organic/synthetic hybrid. https://news.ycombinator.com/item?id=15546769 DonHopkins on Oct 25, 2017 | parent | context | favorite | on: Boustrophedon The Floyd Steinberg error diffusion dithering algorithm can use a boustrophedonous scan order to eliminate the diagonal geometric artifacts you get by scanning each row the same direction. https://en.wikipedia.org/wiki/Floyd%E2%80%93Steinberg_dither... "In some implementations, the horizontal direction of scan alternates between lines; this is called "serpentine scanning" or boustrophedon transform dithering." I implemented some eight bit cellular automata heat diffusion rules with error diffusion, which accumulated an unfortunate drift up and to the right because of the scan order. Rudy Rucker pointed out the problem: https://web.archive.org/web/20180909074032/http://donhopkins... "Rudy Rucker: I feel like you might have some kind of bug in your update code, an off-by-one thing or a problem with the buffer flipping. My reason is that I see persistent upward drift in the action, like if I mouse drag a blob it generally moves up. Also the patterns appearing in the blob aren't uniform. I mean...this IS supposed to be the 2D Rug rule, isn't it?" So instead of scanning back and forth boustrophedoniously (which wouldn't eliminate the vertical drift, just the horizontal drift), I rotated the direction of scanning 90 degrees each frame ("spinning scan") to spread the drift out evenly in all directions over time. https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... // Rotate the direction of scanning 90 degrees every step, // to cancel out the dithering artifacts that would cause the // heat to drift up and to the right. That totally canceled out the unwanted drifting and geometric dithering artifacts! That made it possible to cultivate much more subtle (or not-so-subtle) effects, like dynamically switching per-cell between different anisotropic convolution kernels (see the "Twistier Marble" rule for an extreme example). http://donhopkins.com/home/CAM6 CAM6 Demo: https://www.youtube.com/watch?v=LyLMHxRNuck Demo of Don Hopkins' CAM6 Cellular Automata Machine simulator. Live App: https://donhopkins.com/home/CAM6 Github Repo: https://github.com/SimHacker/CAM6 Javacript Source Code: https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... Comments from the code: // This code originally started life as a CAM6 simulator written in C // and Forth, based on the original CAM6 hardware and compatible with // the brilliant Forth software developed by Toffoli and Margolus. But // then it took on a life of its own (not to mention a lot of other CA // rules), and evolved into supporting many other cellular automata // rules and image processing effects. Eventually it was translated to // C++ and Python, and then more recently it has finally been // rewritten from the ground up in JavaScript. // The CAM6 hardware and Forth software for defining rules and // orchestrating simulations is thoroughly described in this wonderful // book by Tommaso Toffoli and Norman Margolus of MIT. // Cellular Automata Machines: A New Environment for Modeling // Published April 1987 by MIT Press. ISBN: 9780262200608. // http://mitpress.mit.edu/9780262526319/

rground potatoes and fancy flowers: https://studio.sandspiel.club/user/clanzgor8006109mtjooi348t I've written more about Sandspeil Studio and related topics of artificial life, cellular automata, and visual programming, and quoted some interesting discussion with Max and TodePond from their Discord server (they actually already knew about most of this stuff, but they love it as much as I do), in the "Ask HN: What weird technical scene are you fond/part of?" discussion, in reply to api's comment about Digital Artificial Life: https://news.ycombinator.com/item?id=33698163 api 67 days ago | parent | context | favorite | on: Ask HN: What weird technical scene are you fond/pa... Digital Artificial Life -- as in evolving program ecosystems, artificial chemistries or cellular automata that can manifest life-like phenomena, etc. Haven't done much with it in a while but was very into it in college. It's both a minor scientific field (would probably be grouped under both theoretical biology and AI research) and a hobbyist field with some really interesting projects. DonHopkins 67 days ago | prev [–] That's one of my long time interests and hobbies, which I write about on HN and discuss with other people frequently. I'm supposed to be doing something else right now so I'll quickly drop a few disorganized quotes and links here. (Sorry I didn't have time to be more concise!) A few years ago I ran across Max Bittker's beautiful "Sandspiel", which is a delightful cellular automata toy that simulates sand and other rules: https://sandspiel.club/ A few days ago I saw him tweet some amazing stuff that resonated with me, which then led me to discover what he's been working with Lu Wilson (TodePond): Sandspiel Studio -- user definable rules using a block based visual programming language. https://twitter.com/maxbittker "working on goth fungus kidpix": https://twitter.com/maxbittker/status/1593868837111451649 Lu Wilson (TodePond): https://twitter.com/TodePond Sandspiel Studio: https://studio.sandspiel.club/ Sandspiel introduction: https://www.youtube.com/watch?v=ecCVor7mJ6o Sandspiel Studio in 60 seconds: https://www.youtube.com/watch?v=qOA-lR3Xc34 Rainbow Sand: https://www.youtube.com/watch?v=PGTsy79wx4U Huegene: https://www.youtube.com/watch?v=ltpkO7jcFOY Flower: https://www.youtube.com/watch?v=ifyYITDq1oo TodePond's Spellular Automata: https://www.youtube.com/watch?v=xvlsJ3FqNYU We had a great discussion on the Sandspiel Studio Discord server, where I posted some interesting links: Check out the Long Now Foundation talk by Brian Eno and Will Wright about Generative Systems: 10:39 minute excerpt of Will talking about cellular automata and demonstrating with Mirak's Cellebration: https://www.youtube.com/watch?v=UqzVSvqXJYg 6:48 minute excerpt of Will demonstrating Spore Metaverses: https://www.youtube.com/watch?v=7t0kuvz5x_4 6:29 minute excerpt of Will demonstrating Spore Creature Demo: https://www.youtube.com/watch?v=8PXiNNXUUF8 Entire 1:38:50 hour Long Now Foundation talk: Playing with Time | Brian Eno and Will Wright https://www.youtube.com/watch?v=Dfc-DQorohc Craig Reynolds said the name "Boids" was inspired by The Producers Concierge scene, so that's how you should pronounce it: Boids. Dirty, disgusting, filthy, lice ridden Boids. Boids. You get my drift? https://www.youtube.com/watch?v=aL6mTMShVyk The other really cool rabbit hole to explore for generating tiles and even arbitrary graph based content (I'm sold: hexagons are the bestagons!) is "Wave Function Collapse", which doesn't actually have anything to do with quantum mechanics (it just sounds cool), but is actually a kind of constraint solver related to sudoku solvers. https://escholarship.org/content/qt3rm1w0mn/qt3rm1w0mn_noSpl... Maxim Gumin's work: https://github.com/mxgmn/WaveFunctionCollapse Paul Merrell's work: https://paulmerrell.org/model-synthesis/ https://paulmerrell.org/research/ Oskar Stålberg's work: https://twitter.com/OskSta/status/784847588893814785 https://oskarstalberg.com/game/wave/wave.html There's a way to define cellular automata rules by giving examples of the before and after patterns, and WFC is kind of like a statistical constraint solving version of that. So it's really easy for artists to define rules just by drawing! Not even requiring any visual programming, but you can layer visual programming on top of it. That's something that Alexander Repenning's "AgentSheets" supported (among other stuff): you could define cellular automata rules by before-and-after examples, wildcards and variables, and attach additional conditions and actions with a visual programming language. AgentSheets and other cool systems are described in this classic paper: “A Taxonomy of Simulation Software: A work in progress” from Learning Technology Review by Kurt Schmucker at Apple. It covered many of my favorite systems. http://donhopkins.com/home/documents/taxonomy.pdf Chaim Gingold wrote a comprehensive "Gadget Background Survey" at HARC, which includes AgentSheets, Alan Kay's favorites: Rockey’s Boots and Robot Odyssey, and Chaim's amazing SimCity Reverse Diagrams and lots of great stuff I’d never seen before: http://chaim.io/download/Gingold%20(2017)%20Gadget%20(1)%20S... Chaim Gingold has analyzed the SimCity (classic) code and visually documented how it works, in his beautiful "SimCity Reverse Diagrams": >SimCity reverse diagrams: Chaim Gingold (2016). >These reverse diagrams map and translate the rules of a complex simulation program into a form that is more easily digested, embedded, disseminated, and and discussed (Latour 1986). >The technique is inspired by the game designer Stone Librande’s one page game design documents (Librande 2010). If we merge the reverse diagram with an interactive approach—e.g. Bret Victor’s Nile Visualization (Victor 2013), such diagrams could be used generatively, to describe programs, and interactively, to allow rich introspection and manipulation of software. >Latour, Bruno (1986). “Visualization and cognition”. In: Knowledge and Society 6 (1986), pp. 1– 40. Librande, Stone (2010). “One-Page Designs”. Game Developers Conference. 2010. Victor, Bret (2013). “Media for Thinking the Unthinkable”. MIT Media Lab, Apr. 4, 2013. https://lively-web.org/users/Dan/uploads/SimCityReverseDiagr... Agentsheets: Alexander Repenning (1993–) Interacting agents are embedded and interact within cellular spaces called sheets. Agents are reactive to direct manipulation and have autonomous behavior. Agent Sheets draws upon a similarly spirited broad field of paradigms: artificial life, visual programming, “programmable drawing tools,” “simulation environments”, games, cellular automata, and “spreadsheet extensions.” Repenning draws upon these shared characteristics: visual, spatial notation, dynamic, direct manipulation, and incremental agency. The basic tool palette is also a gallery, defined in simulation terms. Highlights: • Kits (“agencies”) describe specific domains. One effect of “|ayered” design is “roles”—end-users vs. scenario designers. Example domains in thesis: Turing machines, circuits, flow, traffic, programs. • Sheet is a cellular 2d space, but agents can be stacked up in a cell. • Incremental refinement of art, behavior, etc… • A highly generalize idea of flow is used for things like neural nets, flow charts, water flow, circuits, system dynamic style models, and traffic. • It also supports ecological style spatial simulations. • User interaction and agent communication is in the same representation. i.e. Anything can do to one another everything the user can. AgentSheets is still going, and has even gone all 3D like Minecraft! AgentCubes! https://agentsheets.com/ Another great visual programming language for kids that supported defining cellular automata rules by example and visual programming: KidSim (later Cocoa, then Stagecast Creator) Smith, David C., Allen Cypher, and James Spohrer (1994) In KidSim graphical simulations are created via graphical rewrite rules, which also enables a kind of programming by demonstration. The creators argue that most people can use editor GUIs (e.g. paint programs), and can give directions, but cannot program. Their solution is to “get rid of the programming language” in favor of a philosophy grounded in GUI design: • Visibility. Relevant information is visible; causality is clear; modelessness. • Copy and modify, not make from scratch. • See and point, not remember and type. • Concrete, not abstract. • Familiar conceptual model. (“minimum translation distance”). They choose a symbolic simulation microworld as a domain because it leads to knowing, ownership, and motivation. All objects are agents which have appearances, properties (name value pairs), and rules. Programming by demonstration extends to using a calculator and dragging properties around to define conditionals. One of the creators of KidSim, David Smith, was also the creator of another graphical programming environment: Pygmalion. Smith, David C., Allen Cypher, and James Spohrer (1994) (Then I ran across TodePond's Spellular Automata video and realized I was preaching to the choir! TodePond wrote: "and stagecast creator is a big inspiration to me! I name-dropped it in a demo I did this week :D") Wow I did not realize I was evangelizing to the choir! This video by TodePond, is exactly what I was talking about, just much more beautiful than I'd imagined possible: https://www.youtube.com/watch?v=xvlsJ3FqNYU I was watching Lex Fredman interview Michael Levin, and Lex expressed the same level of fascination about cellular automata that I have: Michael Levin: Michael Levin: Biology, Life, Aliens, Evolution, Embryogenesis & Xenobots | Lex Fridman Podcast #325 https://www.youtube.com/watch?v=p3lsYlod5OU 1:44:29: Lex: Whenever I think about something like unconventional cognition, I think about cellular automata. I'm just captivated by the beauty of the thing. The fact that from simple little objects you can create such beautiful complexity that very quickly you forget about the individual objects and you see the things that it creates as its own organisms. That blows my mind every time. Like honestly I could full time just eat mushrooms and watch cellular automata. I don't even have to do mushrooms. Cellular automata, it feels like from the engineering perspective, I love when a very simple system captures something really powerful. Because then you can study that system to understand something fundamental about complexity, about life on earth. Anyway how Do I communicate with the thing? If a cellular automata can do cognition, if a plant can do cognition, if a xenobot can do cognition, how do I whisper in its ear and get an answer back, too? How do I have a conversation? How do I have a xenobot on the podcast? Then I watched Lex interview Steven Wolfram: https://www.youtube.com/watch?v=ez773teNFYA Stephen Wolfram: Cellular Automata, Computation, and Physics | Lex Fridman Podcast #89 - YouTube https://www.youtube.com I hate it when a program I wrote mocks me. In Lex Fridman's interview of Steven Wolfram, he demonstrates the machine learning functions in Mathematica by taking a photo of himself, which identifies him as a .... (I won't give it away): https://www.youtube.com/watch?v=ez773teNFYA&t=2h20m05s Here's a video I recently recorded of the CAM-6 simulator I implemented decades ago, and rewrote in JavaScript a few years ago. https://www.youtube.com/watch?v=LyLMHxRNuck I recorded that demo to show to Norman Margolus, who co-wrote the book and wrote the CAM6 PC Forth code and many rules, so it's pretty long and technical and starts out showing lots of code, but I'm sure you'll totally get and appreciate it. I linked to a pdf copy of the book in the comments, as well as the source code and playable app. Demo of Don Hopkins' CAM6 Cellular Automata Machine simulator. Live App: https://donhopkins.com/home/CAM6 Github Repo: https://github.com/SimHacker/CAM6/ Javacript Source Code: https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... PDF of CAM6 Book: https://donhopkins.com/home/cam-book.pdf Comments from the code: // This code originally started life as a CAM6 simulator written in C // and Forth, based on the original CAM6 hardware and compatible with // the brilliant Forth software developed by Toffoli and Margolus. But // then it took on a life of its own (not to mention a lot of other CA // rules), and evolved into supporting many other cellular automata // rules and image processing effects. Eventually it was translated to // C++ and Python, and then more recently it has finally been // rewritten from the ground up in JavaScript. // The CAM6 hardware and Forth software for defining rules and // orchestrating simulations is thoroughly described in this wonderful // book by Tommaso Toffoli and Norman Margolus of MIT. // Cellular Automata Machines: A New Environment for Modeling // Published April 1987 by MIT Press. ISBN: 9780262200608. // http://mitpress.mit.edu/9780262526319/ Here's another demo I recorded a while ago that shows more rules: https://www.loom.com/share/cc09b916134b43cea201b61e71432f32 Making a Falling Sand Simulator: https://news.ycombinator.com/item?id=31309616 Oh My Gosh, It's Covered in Rule 30s: https://news.ycombinator.com/item?id=14458955 Wolfram Rule 30 Prizes: https://news.ycombinator.com/item?id=21130098 Finding Mona Lisa in the Game of Life: https://news.ycombinator.com/item?id=22552006 Andrew Wuensche's and Mike Lesser's gorgeous coffee table book, "The Global Dynamics of Cellular Automata": https://news.ycombinator.com/item?id=22570750 Here's some stuff about Dave Ackley's "Robust First Computing" and "Moveable Feast Machine": https://news.ycombinator.com/item?id=22304063 DonHopkins on Feb 11, 2020 | parent | context | favorite | on: Growing Neural Cellular Automata: A Differentiable... Also check out the "Moveable Feast Machine", Robust-first Computing, and this Distributed City Generation example: https://news.ycombinator.com/item?id=21858577 DonHopkins on Oct 26, 2017 | parent | favorite | on: Cryptography with Cellular Automata (1985) [pdf] A "Moveable Feast Machine" is a "Robust First" asynchronous distributed fault tolerant cellular-automata-like computer architecture. It's similar to a Cellular Automata, but it different in several important ways, for the sake of "Robust First Computing". These differences give some insight into what CA really are, and what their limitations are. Cellular Automata are synchronous and deterministic, and can only modify the current cell: all cells are evaluated at once (so the evaluation order doesn't matter), so it's necessary to double buffer the "before" and "after" cells, and the rule can only change the value of the current (center) cell. Moveable Feast Machines are like asynchronous non-deterministic cellular automata with large windows that can modify adjacent cells. Here's a great example with an amazing demo and explanation, and some stuff I posted about it earlier: https://news.ycombinator.com/item?id=14236973 Robust-first Computing: Distributed City Generation: https://www.youtube.com/watch?v=XkSXERxucPc https://news.ycombinator.com/item?id=22304110 DonHopkins on Feb 11, 2020 | parent | context | favorite | on: Growing Neural Cellular Automata: A Differentiable... Dave Ackley, who developed the Moveable Feast Machine, had some interesting thoughts about moving from 2D to 3D grids of cells: https://news.ycombinator.com/item?id=21131468 DonHopkins 4 months ago | parent | favorite | on: Wolfram Rule 30 Prizes Very beautiful and artistically rendered! Those would make great fireworks and weapons in Minecraft! From a different engineering perspective, Dave Ackley had some interesting things to say about the difficulties of going from 2D to 3D, which I quoted in an earlier discussion about visual programming: https://news.ycombinator.com/item?id=18497585 David Ackley, who developed the two-dimensional CA-like "Moveable Feast Machine" architecture for "Robust First Computing", touched on moving from 2D to 3D in his retirement talk: https://youtu.be/YtzKgTxtVH8?t=3780 "Well 3D is the number one question. And my answer is, depending on what mood I'm in, we need to crawl before we fly." "Or I say, I need to actually preserve one dimension to build the thing and fix it. Imagine if you had a three-dimensional computer, how you can actually fix something in the middle of it? It's going to be a bit of a challenge." "So fundamentally, I'm just keeping the third dimension in my back pocket, to do other engineering. I think it would be relatively easy to imaging taking a 2D model like this, and having a finite number of layers of it, sort of a 2.1D model, where there would be a little local communication up and down, and then it was indefinitely scalable in two dimensions." "And I think that might in fact be quite powerful. Beyond that you think about things like what about wrap-around torus connectivity rooowaaah, non-euclidian dwooraaah, aaah uuh, they say you can do that if you want, but you have to respect indefinite scalability. Our world is 3D, and you can make little tricks to make toruses embedded in a thing, but it has other consequences." Here's more stuff about the Moveable Feast Machine: https://news.ycombinator.com/item?id=15560845 https://news.ycombinator.com/item?id=14236973 The most amazing mind blowing demo is Robust-first Computing: Distributed City Generation: https://www.youtube.com/watch?v=XkSXERxucPc And a paper about how that works: https://www.cs.unm.edu/~ackley/papers/paper_tsmall1_11_24.pd... Plus there's a lot more here: https://movablefeastmachine.org/ Now he's working on a hardware implementation of indefinitely scalable robust first computing: https://www.youtube.com/channel/UC1M91QuLZfCzHjBMEKvIc-A John von Neumann's 29 State Cellular Automata https://news.ycombinator.com/item?id=22304084 John von Neumann's book "Theory of Self-Reproducing Automata": https://news.ycombinator.com/item?id=21858465 Factorio, and Will Wright on simulation games: https://news.ycombinator.com/item?id=24163024

er.com/TodePond Sandspiel Studio: https://studio.sandspiel.club/ Sandspiel introduction: https://www.youtube.com/watch?v=ecCVor7mJ6o Sandspiel Studio in 60 seconds: https://www.youtube.com/watch?v=qOA-lR3Xc34 Rainbow Sand: https://www.youtube.com/watch?v=PGTsy79wx4U Huegene: https://www.youtube.com/watch?v=ltpkO7jcFOY Flower: https://www.youtube.com/watch?v=ifyYITDq1oo TodePond's Spellular Automata: https://www.youtube.com/watch?v=xvlsJ3FqNYU We had a great discussion on the Sandspiel Studio Discord server, where I posted some interesting links: Check out the Long Now Foundation talk by Brian Eno and Will Wright about Generative Systems: 10:39 minute excerpt of Will talking about cellular automata and demonstrating with Mirak's Cellebration: https://www.youtube.com/watch?v=UqzVSvqXJYg 6:48 minute excerpt of Will demonstrating Spore Metaverses: https://www.youtube.com/watch?v=7t0kuvz5x_4 6:29 minute excerpt of Will demonstrating Spore Creature Demo: https://www.youtube.com/watch?v=8PXiNNXUUF8 Entire 1:38:50 hour Long Now Foundation talk: Playing with Time | Brian Eno and Will Wright https://www.youtube.com/watch?v=Dfc-DQorohc Craig Reynolds said the name "Boids" was inspired by The Producers Concierge scene, so that's how you should pronounce it: Boids. Dirty, disgusting, filthy, lice ridden Boids. Boids. You get my drift? https://www.youtube.com/watch?v=aL6mTMShVyk The other really cool rabbit hole to explore for generating tiles and even arbitrary graph based content (I'm sold: hexagons are the bestagons!) is "Wave Function Collapse", which doesn't actually have anything to do with quantum mechanics (it just sounds cool), but is actually a kind of constraint solver related to sudoku solvers. https://escholarship.org/content/qt3rm1w0mn/qt3rm1w0mn_noSpl... Maxim Gumin's work: https://github.com/mxgmn/WaveFunctionCollapse Paul Merrell's work: https://paulmerrell.org/model-synthesis/ https://paulmerrell.org/research/ Oskar Stålberg's work: https://twitter.com/OskSta/status/784847588893814785 https://oskarstalberg.com/game/wave/wave.html There's a way to define cellular automata rules by giving examples of the before and after patterns, and WFC is kind of like a statistical constraint solving version of that. So it's really easy for artists to define rules just by drawing! Not even requiring any visual programming, but you can layer visual programming on top of it. That's something that Alexander Repenning's "AgentSheets" supported (among other stuff): you could define cellular automata rules by before-and-after examples, wildcards and variables, and attach additional conditions and actions with a visual programming language. AgentSheets and other cool systems are described in this classic paper: “A Taxonomy of Simulation Software: A work in progress” from Learning Technology Review by Kurt Schmucker at Apple. It covered many of my favorite systems. http://donhopkins.com/home/documents/taxonomy.pdf Chaim Gingold wrote a comprehensive "Gadget Background Survey" at HARC, which includes AgentSheets, Alan Kay's favorites: Rockey’s Boots and Robot Odyssey, and Chaim's amazing SimCity Reverse Diagrams and lots of great stuff I’d never seen before: http://chaim.io/download/Gingold%20(2017)%20Gadget%20(1)%20S... Chaim Gingold has analyzed the SimCity (classic) code and visually documented how it works, in his beautiful "SimCity Reverse Diagrams": >SimCity reverse diagrams: Chaim Gingold (2016). >These reverse diagrams map and translate the rules of a complex simulation program into a form that is more easily digested, embedded, disseminated, and and discussed (Latour 1986). >The technique is inspired by the game designer Stone Librande’s one page game design documents (Librande 2010). If we merge the reverse diagram with an interactive approach—e.g. Bret Victor’s Nile Visualization (Victor 2013), such diagrams could be used generatively, to describe programs, and interactively, to allow rich introspection and manipulation of software. >Latour, Bruno (1986). “Visualization and cognition”. In: Knowledge and Society 6 (1986), pp. 1– 40. Librande, Stone (2010). “One-Page Designs”. Game Developers Conference. 2010. Victor, Bret (2013). “Media for Thinking the Unthinkable”. MIT Media Lab, Apr. 4, 2013. https://lively-web.org/users/Dan/uploads/SimCityReverseDiagr... Agentsheets: Alexander Repenning (1993–) Interacting agents are embedded and interact within cellular spaces called sheets. Agents are reactive to direct manipulation and have autonomous behavior. Agent Sheets draws upon a similarly spirited broad field of paradigms: artificial life, visual programming, “programmable drawing tools,” “simulation environments”, games, cellular automata, and “spreadsheet extensions.” Repenning draws upon these shared characteristics: visual, spatial notation, dynamic, direct manipulation, and incremental agency. The basic tool palette is also a gallery, defined in simulation terms. Highlights: • Kits (“agencies”) describe specific domains. One effect of “|ayered” design is “roles”—end-users vs. scenario designers. Example domains in thesis: Turing machines, circuits, flow, traffic, programs. • Sheet is a cellular 2d space, but agents can be stacked up in a cell. • Incremental refinement of art, behavior, etc… • A highly generalize idea of flow is used for things like neural nets, flow charts, water flow, circuits, system dynamic style models, and traffic. • It also supports ecological style spatial simulations. • User interaction and agent communication is in the same representation. i.e. Anything can do to one another everything the user can. AgentSheets is still going, and has even gone all 3D like Minecraft! AgentCubes! https://agentsheets.com/ Another great visual programming language for kids that supported defining cellular automata rules by example and visual programming: KidSim (later Cocoa, then Stagecast Creator) Smith, David C., Allen Cypher, and James Spohrer (1994) In KidSim graphical simulations are created via graphical rewrite rules, which also enables a kind of programming by demonstration. The creators argue that most people can use editor GUIs (e.g. paint programs), and can give directions, but cannot program. Their solution is to “get rid of the programming language” in favor of a philosophy grounded in GUI design: • Visibility. Relevant information is visible; causality is clear; modelessness. • Copy and modify, not make from scratch. • See and point, not remember and type. • Concrete, not abstract. • Familiar conceptual model. (“minimum translation distance”). They choose a symbolic simulation microworld as a domain because it leads to knowing, ownership, and motivation. All objects are agents which have appearances, properties (name value pairs), and rules. Programming by demonstration extends to using a calculator and dragging properties around to define conditionals. One of the creators of KidSim, David Smith, was also the creator of another graphical programming environment: Pygmalion. Smith, David C., Allen Cypher, and James Spohrer (1994) (Then I ran across TodePond's Spellular Automata video and realized I was preaching to the choir! TodePond wrote: "and stagecast creator is a big inspiration to me! I name-dropped it in a demo I did this week :D") Wow I did not realize I was evangelizing to the choir! This video by TodePond, is exactly what I was talking about, just much more beautiful than I'd imagined possible: https://www.youtube.com/watch?v=xvlsJ3FqNYU I was watching Lex Fredman interview Michael Levin, and Lex expressed the same level of fascination about cellular automata that I have: Michael Levin: Michael Levin: Biology, Life, Aliens, Evolution, Embryogenesis & Xenobots | Lex Fridman Podcast #325 https://www.youtube.com/watch?v=p3lsYlod5OU 1:44:29: Lex: Whenever I think about something like unconventional cognition, I think about cellular automata. I'm just captivated by the beauty of the thing. The fact that from simple little objects you can create such beautiful complexity that very quickly you forget about the individual objects and you see the things that it creates as its own organisms. That blows my mind every time. Like honestly I could full time just eat mushrooms and watch cellular automata. I don't even have to do mushrooms. Cellular automata, it feels like from the engineering perspective, I love when a very simple system captures something really powerful. Because then you can study that system to understand something fundamental about complexity, about life on earth. Anyway how Do I communicate with the thing? If a cellular automata can do cognition, if a plant can do cognition, if a xenobot can do cognition, how do I whisper in its ear and get an answer back, too? How do I have a conversation? How do I have a xenobot on the podcast? Then I watched Lex interview Steven Wolfram: https://www.youtube.com/watch?v=ez773teNFYA Stephen Wolfram: Cellular Automata, Computation, and Physics | Lex Fridman Podcast #89 - YouTube https://www.youtube.com I hate it when a program I wrote mocks me. In Lex Fridman's interview of Steven Wolfram, he demonstrates the machine learning functions in Mathematica by taking a photo of himself, which identifies him as a .... (I won't give it away): https://www.youtube.com/watch?v=ez773teNFYA&t=2h20m05s Here's a video I recently recorded of the CAM-6 simulator I implemented decades ago, and rewrote in JavaScript a few years ago. https://www.youtube.com/watch?v=LyLMHxRNuck I recorded that demo to show to Norman Margolus, who co-wrote the book and wrote the CAM6 PC Forth code and many rules, so it's pretty long and technical and starts out showing lots of code, but I'm sure you'll totally get and appreciate it. I linked to a pdf copy of the book in the comments, as well as the source code and playable app. Demo of Don Hopkins' CAM6 Cellular Automata Machine simulator. Live App: https://donhopkins.com/home/CAM6 Github Repo: https://github.com/SimHacker/CAM6/ Javacript Source Code: https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... PDF of CAM6 Book: https://donhopkins.com/home/cam-book.pdf Comments from the code: // This code originally started life as a CAM6 simulator written in C // and Forth, based on the original CAM6 hardware and compatible with // the brilliant Forth software developed by Toffoli and Margolus. But // then it took on a life of its own (not to mention a lot of other CA // rules), and evolved into supporting many other cellular automata // rules and image processing effects. Eventually it was translated to // C++ and Python, and then more recently it has finally been // rewritten from the ground up in JavaScript. // The CAM6 hardware and Forth software for defining rules and // orchestrating simulations is thoroughly described in this wonderful // book by Tommaso Toffoli and Norman Margolus of MIT. // Cellular Automata Machines: A New Environment for Modeling // Published April 1987 by MIT Press. ISBN: 9780262200608. // http://mitpress.mit.edu/9780262526319/ Here's another demo I recorded a while ago that shows more rules: https://www.loom.com/share/cc09b916134b43cea201b61e71432f32 Making a Falling Sand Simulator: https://news.ycombinator.com/item?id=31309616 Oh My Gosh, It's Covered in Rule 30s: https://news.ycombinator.com/item?id=14458955 Wolfram Rule 30 Prizes: https://news.ycombinator.com/item?id=21130098 Finding Mona Lisa in the Game of Life: https://news.ycombinator.com/item?id=22552006 Andrew Wuensche's and Mike Lesser's gorgeous coffee table book, "The Global Dynamics of Cellular Automata": https://news.ycombinator.com/item?id=22570750 Here's some stuff about Dave Ackley's "Robust First Computing" and "Moveable Feast Machine": https://news.ycombinator.com/item?id=22304063 DonHopkins on Feb 11, 2020 | parent | context | favorite | on: Growing Neural Cellular Automata: A Differentiable... Also check out the "Moveable Feast Machine", Robust-first Computing, and this Distributed City Generation example: https://news.ycombinator.com/item?id=21858577 DonHopkins on Oct 26, 2017 | parent | favorite | on: Cryptography with Cellular Automata (1985) [pdf] A "Moveable Feast Machine" is a "Robust First" asynchronous distributed fault tolerant cellular-automata-like computer architecture. It's similar to a Cellular Automata, but it different in several important ways, for the sake of "Robust First Computing". These differences give some insight into what CA really are, and what their limitations are. Cellular Automata are synchronous and deterministic, and can only modify the current cell: all cells are evaluated at once (so the evaluation order doesn't matter), so it's necessary to double buffer the "before" and "after" cells, and the rule can only change the value of the current (center) cell. Moveable Feast Machines are like asynchronous non-deterministic cellular automata with large windows that can modify adjacent cells. Here's a great example with an amazing demo and explanation, and some stuff I posted about it earlier: https://news.ycombinator.com/item?id=14236973 Robust-first Computing: Distributed City Generation: https://www.youtube.com/watch?v=XkSXERxucPc https://news.ycombinator.com/item?id=22304110 DonHopkins on Feb 11, 2020 | parent | context | favorite | on: Growing Neural Cellular Automata: A Differentiable... Dave Ackley, who developed the Moveable Feast Machine, had some interesting thoughts about moving from 2D to 3D grids of cells: https://news.ycombinator.com/item?id=21131468 DonHopkins 4 months ago | parent | favorite | on: Wolfram Rule 30 Prizes Very beautiful and artistically rendered! Those would make great fireworks and weapons in Minecraft! From a different engineering perspective, Dave Ackley had some interesting things to say about the difficulties of going from 2D to 3D, which I quoted in an earlier discussion about visual programming: https://news.ycombinator.com/item?id=18497585 David Ackley, who developed the two-dimensional CA-like "Moveable Feast Machine" architecture for "Robust First Computing", touched on moving from 2D to 3D in his retirement talk: https://youtu.be/YtzKgTxtVH8?t=3780 "Well 3D is the number one question. And my answer is, depending on what mood I'm in, we need to crawl before we fly." "Or I say, I need to actually preserve one dimension to build the thing and fix it. Imagine if you had a three-dimensional computer, how you can actually fix something in the middle of it? It's going to be a bit of a challenge." "So fundamentally, I'm just keeping the third dimension in my back pocket, to do other engineering. I think it would be relatively easy to imaging taking a 2D model like this, and having a finite number of layers of it, sort of a 2.1D model, where there would be a little local communication up and down, and then it was indefinitely scalable in two dimensions." "And I think that might in fact be quite powerful. Beyond that you think about things like what about wrap-around torus connectivity rooowaaah, non-euclidian dwooraaah, aaah uuh, they say you can do that if you want, but you have to respect indefinite scalability. Our world is 3D, and you can make little tricks to make toruses embedded in a thing, but it has other consequences." Here's more stuff about the Moveable Feast Machine: https://news.ycombinator.com/item?id=15560845 https://news.ycombinator.com/item?id=14236973 The most amazing mind blowing demo is Robust-first Computing: Distributed City Generation: https://www.youtube.com/watch?v=XkSXERxucPc And a paper about how that works: https://www.cs.unm.edu/~ackley/papers/paper_tsmall1_11_24.pd... Plus there's a lot more here: https://movablefeastmachine.org/ Now he's working on a hardware implementation of indefinitely scalable robust first computing: https://www.youtube.com/channel/UC1M91QuLZfCzHjBMEKvIc-A John von Neumann's 29 State Cellular Automata https://news.ycombinator.com/item?id=22304084 John von Neumann's book "Theory of Self-Reproducing Automata": https://news.ycombinator.com/item?id=21858465 Factorio, and Will Wright on simulation games: https://news.ycombinator.com/item?id=24163024

decidedly "non von Neumann architecture". https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton He wrote the book on "Theory of Self-Reproducing Automata": https://archive.org/details/theoryofselfrepr00vonn_0 He designed a 29 state cellular automata architecture to implement a universal constructor that could reproduce itself (which he worked out on paper, amazingly): https://en.wikipedia.org/wiki/Von_Neumann_universal_construc... He actually philosophized about three different kinds of universal constructors at different levels of reality: First, the purely deterministic and relatively harmless mathematical kind referenced above, an idealized abstract 29 state cellular automata, which could reproduce itself with a Universal Constructor, but was quite brittle, synchronous, and intolerant of errors. These have been digitally implemented in the real world on modern computing machinery, and they make great virtual pets, kind of like digital tribbles, but not as cute and fuzzy. https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... Second, the physical mechanical and potentially dangerous kind, which is robust and error tolerant enough to work in the real world (given enough resources), and is now a popular theme in sci-fi: the self reproducing robot swarms called "Von Neumann Probes" on the astronomical scale, or "Gray Goo" on the nanotech scale. https://en.wikipedia.org/wiki/Self-replicating_spacecraft#Vo... https://grey-goo.fandom.com/wiki/Von_Neumann_probe >The von Neumann probe, nicknamed the Goo, was a self-replicating nanomass capable of traversing through keyholes, which are wormholes in space. The probe was named after Hungarian-American scientist John von Neumann, who popularized the idea of self-replicating machines. Third, the probabilistic quantum mechanical kind, which could mutate and model evolutionary processes, and rip holes in the space-time continuum, which he unfortunately (or fortunately, the the sake of humanity) didn't have time to fully explore before his tragic death. p. 99 of "Theory of Self-Reproducing Automata": >Von Neumann had been interested in the applications of probability theory throughout his career; his work on the foundations of quantum mechanics and his theory of games are examples. When he became interested in automata, it was natural for him to apply probability theory here also. The Third Lecture of Part I of the present work is devoted to this subject. His "Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components" is the first work on probabilistic automata, that is, automata in which the transitions between states are probabilistic rather than deterministic. Whenever he discussed self-reproduction, he mentioned mutations, which are random changes of elements (cf. p. 86 above and Sec. 1.7.4.2 below). In Section 1.1.2.1 above and Section 1.8 below he posed the problems of modeling evolutionary processes in the framework of automata theory, of quantizing natural selection, and of explaining how highly efficient, complex, powerful automata can evolve from inefficient, simple, weak automata. A complete solution to these problems would give us a probabilistic model of self-reproduction and evolution. [9] [9] For some related work, see J. H. Holland, "Outline for a Logical Theory of Adaptive Systems", and "Concerning Efficient Adaptive Systems". https://www.deepdyve.com/lp/association-for-computing-machin... https://deepblue.lib.umich.edu/bitstream/handle/2027.42/5578... https://www.worldscientific.com/worldscibooks/10.1142/10841 Ericson2314 3 months ago [-] > Although I refer to conventional languages as "von Neumann languages" to take note of their origin and style, I do not, of course, blame the great mathematician for their complexity. In fact, some might say that I bear some responsibility for that problem. From the paper. Whew.

odd step, and which of the four squares of the grid it's in. That's how the CAM6 worked in hardware: it used the x/y/time phases as additional bits to determine the Margolus neighborhood lookup table index. https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... Here's how my CAM6 emulator computes the CAM6-hardware-compatible Margolus lookup table index, based on the 9 Moore neighbors + phaseTime, phaseX, and phaseY: function getTableIndexUnrotated( nw, n, ne, w, c, e, sw, s, se, phaseTime, phaseX, phaseY) { // 0 1 2 3 4 5 6 7 8 9 // c0 c1 cw0 ccw0 opp0 cw1 ccw1 opp1 pha0 pha1 // 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80 0x100 0x200 var cw, ccw, opp; if (phaseTime) { return ( // c c' (c & 0x03) | // cw cw' (cw = (phaseX ? (phaseY ? (e & 0x03) : (n & 0x03)) : (phaseY ? (s & 0x03) : (w & 0x03))), (((cw & 0x01) << 2) | ((cw & 0x02) << 4))) | // ccw ccw' (ccw = (phaseX ? (phaseY ? (s & 0x03) : (e & 0x03)) : (phaseY ? (w & 0x03) : (n & 0x03))), (((ccw & 0x01) << 3) | ((ccw & 0x02) << 5))) | // opp opp' (opp = (phaseX ? (phaseY ? (se & 0x03) : (ne & 0x03)) : (phaseY ? (sw & 0x03) : (nw & 0x03))), (((opp & 0x01) << 4) | ((opp & 0x02) << 6))) | // pha pha' 0x200); } else { return ( // c c' (c & 0x03) | // cw cw' (cw = (phaseX ? (phaseY ? (w & 0x03) : (s & 0x03)) : (phaseY ? (n & 0x03) : (e & 0x03))), (((cw & 0x01) << 2) | ((cw & 0x02) << 4))) | // ccw ccw' (ccw = (phaseX ? (phaseY ? (n & 0x03) : (w & 0x03)) : (phaseY ? (e & 0x03) : (s & 0x03))), (((ccw & 0x01) << 3) | ((ccw & 0x02) << 5))) | // opp opp' (opp = (phaseX ? (phaseY ? (nw & 0x03) : (sw & 0x03)) : (phaseY ? (ne & 0x03) : (se & 0x03))), (((opp & 0x01) << 4) | ((opp & 0x02) << 6))) | // pha pha' 0x100); } };

ight “land” cells. We run Brain in the sea, and on land we run not Life but AntiLife. All the land cells are normally firing cells, and the presence of an active AntiLife cell is signaled by having a land cell which is not firing. Full details on EcoLiBra are in the Cellular Automata Theory chapter. >The name EcoLiBra suggests 1) an ecology of Life and Brain, 2) a balanced situation (equilibrium), and 3) the human intestinal bacteria Escherichia coli, known as E. coli for short. The third connection is perhaps a bit unsavory, but remember that E. coli cells are in fact the favorite “guinea pigs” for present day gene splicing experiments. As one of the goals of CelLab is to promote the development of artificial life, the designer gene connection is entirely appropriate. I've given EcoLiBra a nice, symmetric start pattern, but it also does fine if you use the Bit Plane Editor to randomize all bit planes. https://www.fourmilab.ch/cellab/manual/chap4.html#EcoLiBra >The EcoLiBra rule, consisting of Brain and AntiLife, each turned on by the red/black boundary. >But when the sea runs Brain and the land runs Life, the situation is no longer symmetrical. The pervasive presence of Brain's refractory state makes it less likely for a sea cell to have seven firing neighbors and be turned into a land cell. Unless we change the transition rules, the land will always melt away. So to give land a fighting chance, I now say that a sea cell becomes land if it has seven or six firing neighbors. Also I use better colors: Black, blue, and green for Brain; red and yellow for AntiLife. Here is a variant I call "ECO" that runs "ANNEAL" on the water/land plane, and (for giggles) a heat diffusion in the upper left-over planes. https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... [More discussion and code in the original post...] https://news.ycombinator.com/item?id=22438816

oducing Automata": https://archive.org/details/theoryofselfrepr00vonn_0 He designed a 29 state cellular automata architecture to implement a universal constructor that could reproduce itself (which he worked out on paper, amazingly): https://en.wikipedia.org/wiki/Von_Neumann_universal_construc... He actually philosophized about three different kinds of universal constructors at different levels of reality: First, the purely deterministic and relatively harmless mathematical kind referenced above, an idealized abstract 29 state cellular automata, which could reproduce itself with a Universal Constructor, but was quite brittle, synchronous, and intolerant of errors. These have been digitally implemented in the real world on modern computing machinery, and they make great virtual pets, kind of like digital tribbles, but not as cute and fuzzy. https://github.com/SimHacker/CAM6/blob/master/javascript/CAM... Second, the physical mechanical and potentially dangerous kind, which is robust and error tolerant enough to work in the real world (given enough resources), and is now a popular theme in sci-fi: the self reproducing robot swarms called "Von Neumann Probes" on the astronomical scale, or "Gray Goo" on the nanotech scale. https://en.wikipedia.org/wiki/Self-replicating_spacecraft#Vo... https://grey-goo.fandom.com/wiki/Von_Neumann_probe >The von Neumann probe, nicknamed the Goo, was a self-replicating nanomass capable of traversing through keyholes, which are wormholes in space. The probe was named after Hungarian-American scientist John von Neumann, who popularized the idea of self-replicating machines. Third, the probabilistic quantum mechanical kind, which could mutate and model evolutionary processes, and rip holes in the space-time continuum, which he unfortunately (or fortunately, the the sake of humanity) didn't have time to fully explore before his tragic death. p. 99 of "Theory of Self-Reproducing Automata": >Von Neumann had been interested in the applications of probability theory throughout his career; his work on the foundations of quantum mechanics and his theory of games are examples. When he became interested in automata, it was natural for him to apply probability theory here also. The Third Lecture of Part I of the present work is devoted to this subject. His "Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components" is the first work on probabilistic automata, that is, automata in which the transitions between states are probabilistic rather than deterministic. Whenever he discussed self-reproduction, he mentioned mutations, which are random changes of elements (cf. p. 86 above and Sec. 1.7.4.2 below). In Section 1.1.2.1 above and Section 1.8 below he posed the problems of modeling evolutionary processes in the framework of automata theory, of quantizing natural selection, and of explaining how highly efficient, complex, powerful automata can evolve from inefficient, simple, weak automata. A complete solution to these problems would give us a probabilistic model of self-reproduction and evolution. [9] [9] For some related work, see J. H. Holland, "Outline for a Logical Theory of Adaptive Systems", and "Concerning Efficient Adaptive Systems". https://www.deepdyve.com/lp/association-for-computing-machin... https://deepblue.lib.umich.edu/bitstream/handle/2027.42/5578... https://www.worldscientific.com/worldscibooks/10.1142/10841 Ericson2314 3 months ago [-] > Although I refer to conventional languages as "von Neumann languages" to take note of their origin and style, I do not, of course, blame the great mathematician for their complexity. In fact, some might say that I bear some responsibility for that problem. From the paper. Whew.