The Moveable Feast Machine is kind of like a cellular automata, but it has a larger neighborhood extending out in a radius of several cells, it has read/write access to every cell in that neighborhood (not just the center), and it's non-deterministic in the order the rules are applied to the cells. It's embarrassingly parallel because it executes randomly chosen non-overlapping neighborhood regions in parallel.
>the division into squares shifts right and down by one cell each direction.
The MFM non-deterministic equivalent of the Margolus neighborhood's alternating x,y offset is to randomly execute non-overlapping neighborhoods in parallel. That has the same effect of incrementally diffusing information evenly in all directions over time, just not perfectly, synchronously, symmetrically, and deterministically like the Margolus neighborhood does.
Moveable Feast Machine rules make it much easy to implement particle based simulations than with traditional cellular automata rules, which compute just the center cell. Instead, the MFM rules can simply "pick up and move" any number of particles within the wider neighborhood.
They can implement all kinds of interesting chemical and biological behaviors between locally interacting particles, like holding molecules of different particles together with atomic bonds, and constructing membranes like cell walls that separate and contain and transport other particles, and implementing magical computational "force fields" and "tractor beams" and "traffic lights" that route other particles around. They're even good for simulating computational DNA-like behaviors:
https://www.youtube.com/watch?v=DauJ51CTIq8
>Programming the Movable Feast Machine with λ-Codons
>λ-Codons provide a mechanism for describing arbitrary computations in the Movable Feast Machine (MFM). A collection of λ-Codon molecules describe the computation by a series of primitive functions. Evaluator particles carry along a stack of memory (which initially contains the input to the program) and visit the λ-Codons, which they interpret as functions and apply to their stacks. When the program completes, they transmute into output particles and carry the answer to the output terminals (left).
The Moveable Feast Machine is similar to cellular automata, but different in some important ways, that make it extremely robust and fault tolerant:
It's a "Robust First" asynchronous distributed fault tolerant cellular-automata-like computer architecture.
Robust programs running on massively parallel unreliable hardware can actually tolerate hardware failure and repair themselves. The Demon Hoard Sort algorithm is an inherently robust sorting algorithm for the Moveable Feast Machine.
http://movablefeastmachine.org/
The "Distributed City Generation" video demonstrates a Movable Feast Machine rule that builds a self-healing city that fills all available space with urban sprawl, with cars that drive between buildings, and city streets that adaptively learn how to route the cars to their nearest destinations, and the city even repairs itself after disasters!
https://www.youtube.com/watch?v=XkSXERxucPc
Here's some more info:
https://news.ycombinator.com/item?id=14236973
JavaScript implementation:
https://mfm.rocks/
https://github.com/walpolea/MFM-JS
Robust First Wiki:
http://robust.cs.unm.edu/doku.php