Me: oh cool, this is interesting, I don’t quite understand what exactly that means, let me read the thread to learn more…
The thread:
> Replacing ECCA1 by version with step after the direction change could save something like 1% of the ecca1 bits size. Compiling agnosticized program instead of fixed lane program by ecca1 could save something like 1% as well (just guesses). Build of smaller ECCA1 would shorten binary portion, but it would be hardly seen in the ship size.
> Using agnosticized recipe in the fuse portion would definitely reduce its size. Better cordership seed and better salvo for gpse90 would help…
Dear lord I had no idea there’s this much jargon in the game of life community. Gonna be reading the wiki for hours
That's because it's not "game of life jargon", it's "cellular automata" jargon. Which is a field of math and comes along with a bunch of math jargon from related fields.
I searched several of these terms and they are all specifically jargon of game of life enthusiasts, (i.e. search reaults are all on fansites related to game of life) not general cellular automata jargon.
Once a year or so I find myself on those forums and I'm always astounded how many people there are that dedicate massive amounts of time and brain power to this.
I’m not sure where our guidelines/norms are on this kind of thing, but I get the sense that most of us feel very capable of pasting articles into LLMs ourselves.
What we’re less capable of—and the reason we look to each other here instead—is distinguishing where the LLM’s errors or misinterpretations lie. The gross mistakes are often easy enough to spot, but the subtle misstatements get masked by its overconfidence.
Luckily for us, a lot of the same people actually doing the work on the stuff we care about tend to hang out around here. And often, they’re kind enough to duck in and share.
Thank you in any case for being upfront about it. It’s just that it’d be a shame and a real loss if the slop noise came to drown out the signal here.
Reading a long explanation on a GoL forum is a great way to experience what it’s like for my spouse to listen to my work conversations on Zoom. This jargon is fantastic.
Two of the most fascinating open questions about the Game of Life are in my opinion:
1. What is the behavior of Conway's Game of Life when the initial position is random? Paraphrasing Boris Bukh's comment on the post linked below, the Game of Life supports self-replication and is Turing-complete, and therefore can support arbitrarily intelligent programs. So, will a random initial position (tend to) be filled with super-intelligent life forms, or will the chaos reign?
There exist uncountably infinitely many particular initial configurations out of which a random one may be drawn, which makes this more difficult (a particular infinite grid configuration can be represented as the binary digits (fractional part) of a real number, spiraling outwards from a given center coordinate cell: 0.0000... represents an empty infinite grid, 0.1111... a fully alive infinite grid).
2. Relatedly, does a superstable configuration exist? One that continues to exist despite any possible external interference pattern on its border? Perhaps even an expanding one?
One problem is that, even though it is turing-complete, many practical operations are very difficult. Patterns tend towards chaos and they tend towards fading out, which are not good properties for useful computation. Simply moving information from one part of the grid to another requires complex structures like spaceships.
You might have better luck with other variants. Reversible cellular automata have a sort of 'conservation of mass' where cells act more like particles. Continuous cellular automata (like Lenia) have less chaotic behavior. Neural cellular automata can be trained with gradient descent.
My understanding (which could be wildly wrong, I only skimmed the thread) is that it's running in a standard 2-dimensional Game of Life grid, it just happens to start out as a 1x3.7B cell line.
It's possible. It'd just be a 3D visualization and more importantly, stupendously huge. If each cell was a cubic millimeter, the shape would be 3700km wide, and stretch 1/3rd of the way to the moon.
Someone figured out how to create a glider that starts and ends as a long string of cells on a single line. Gliders are figures in the game of life that move themselves in a direction by repeated patterns that result in movement. For more game of life/glider context you can read the pretty decent Wikipedia articles:
As noted by others, the title is mistaken; this is a spaceship, not a glider. (As explained in the Wikipedia article, "glider" refers to a specific 5-cell pattern discovered very early on.)
> So finally 2/133076755768 ship of starting bounding box 3707300605x1 is here
My understanding is that 2/133076755768 is the speed, in (number of cells translated) / (number of generations to repeat).
It's already being done. Has been done for decades now. Definitely wouldn't be a good use of an LLM-type model if that's what you're proposing
If you look at the placement of Journal of Cellular Automata in SciMago's Shape of Science visualization[0] you'll see that it's completely surrounded by machine learning/AI journals
Sometimes I feel a deep sense of loss of the old web that grew up with -full of niche interests, unashamedly earnest and rich in subcultures- has been lost in a sea of corporate slop and clickbait social media.
Then occasionally I come across something like this and it feels like all is not lost. Conway's GoL was one of the first C programmes I ever wrote and I've long been distantly fascinated by cellular automata but I had no idea that there was such a depth of research (work, experimentation, collaboration? how do you even describe this kind of collective endeavour?) into GoL lurking out there all these years.
Specifically, after 133_076_755_768 steps, the 1-dimensional pattern reoccurs translated by two pixels. On skimming the thread I haven't determined if that shift is parallel or perpendicular to the line.
Unidimensional spaceship can be interpreted as a demonstration of the progress of recent years in slow salvo technology and the various arms that use it.
The project uses 4 construction arms, with the last three sharing principles with the arms used in the RCT15 project. The first arm is newly invented just for this case. I was not part of the community at the time the principles of the first two arms were studied, but let me describe them anyway.
The one line restriction limit us to using blinkers as the basis of the first arm. Interestingly, a small perturbation at the end of some blinker configuration makes the pattern unstable, and several blinker patterns allow the perturbation "fuse" to move in a controlled manner. Various configurations have been discovered that leave no debris but move at different speeds. Some configurations have been found that produce backward-firing mwss (and leave debris), head-on collisions of mwss that transform them into gliders for both glider colors. By combining these configurations, we can trigger a fusion in the middle of a carefully chosen arrangement of blinkers that would synchronize the mwss collisions at the desired time parity at a prescribed x-coordinate and generate a glider with a prescribed phase and trajectory, so that such an arm could create any p2 recipe.
The second arm used is a binary arm, where a pair of synchronized gliders on the same trajectories are used, with one glider always present and the presence of the other gliders allowing modification of the resulting configuration. Careful study of the results of various words using letters "1" and "2" (indicating the presence of the second glider) led to the discovery of specific modifications of the target "anchor" configuration.
Some of them allow you to move the "head" of the anchor stack to move closer/farther from the base of the arm. Some sequences will generate a perpendicular glider. Not all mod 8 phases and colors are known, but with careful "head positioning" any p8 recipe could be built with such an arm. The program used for the translation only used single blinker anchor technology, which produces a glider for a cost of around 100 bits ("letters").
The agnosticisation salvas of the p8 recipe to use only the p1/p2 constraints on the glider phases (when possible) greatly reduces the number of bits required. Alternative glider paths also help, leading to the same stable configurations during a slow salvas. Currently, there is an alternative method with around 80 bits per glider using 4 different anchors deep in the "arm target stack".
The code could be improved by some form of dynamic programming by compiling the salvo from the parts emitting gliders closest to the arm to the gliders further away from the arm, but there was no need to complete the project.
The third and fourth arms are extreme compression construction arms "ecca", where a programming language interpreter is created and individual incoming letters are interpreted as instructions specifying which phase (mod 2) and line of glider to emit.
We have achieved an optimal encoding that requires about 7-8 bits to emit a typical slow p2 salvo of gliders.
The instruction set includes a move direction change option, move4 (repeated), move2, move1, color option, phase option.
Stopping the move4 loop results in a glider being fired "near" the current arm position after a defined number of letters.
The third arm uses exactly this set of options, while the fourth arm executes move1 after a change of direction, further increasing its efficiency. The fourth arm uses "yellow lane" filtering technology, which allows its components to be recycled, resulting in a more compact and less expensive design.
On the contrary ecca1 is built as p1 pattern what allows selecting less expensive options during the build by the binary arm (at few places where p8 restriction would be required in ecca2 build).
The arms are capable of firing gliders with 4 combinations of phase mode 8 and color (all four combinations of phase mode 2 and color). This is perfectly fine for slow salvos with a p2 restriction, but building p8 salvos requires limiting the salvos to use only a limited set of "signature" color combinations of glider phases.
This led to a modification of the psamake program (transforming "neo" Spartan configurations for slow salvos that are built from a single block). When a bespoke subsalvo builds a p8 pattern (initial call by a single glider), a 0 degree one time turner prefix is optionally allowed for a phase/color correction. Similarly, p2 salvos are transformed to the required p8 phases corresponding to the signature.
There are several other prerequisites for building a ship. We should implement a storage where the bits to be fed into the binary arm and later into the ecca1 and ecca2 arms are encoded. Fortunately, a slow salvo of 8 gliders fired symmetrically into the central "spine" of the track from both sides (the ship cannot lose symmetry) will create 4 blocks near the spine if there was nothing there, or move the blinker from its given position by 2 pixels (east) emitting glider back.
There are a few more requirements to build the ship. We should implement a storege of bits that will be fed into the binary arm and later into the ECCA1 and ECCA2 arms. Fortunately, a slow salvo of 8 gliders fired symmetrically into the central “spine” track from both sides (the ship cannot lose symmetry) will create 4 blocks near the spine if there is nothing there, or move the blinker from its current position by 2 pixels (east) emitting glider backward.
The fuse arm fires 8 90 degree glider producing switch engines “GPSE90” that fire the slow salvo and convert the blinkers on the spine into a traveling signal.
The signal is then fed into the binary arm by a pair of gliders firing the gliders back. One of the gliders is reflected so that they annihilate on impact. The glider signal from the tape annihilates the glider from one stream (negative signal), so the reflected glider from the other stream is not annihilated at the start of the arm. The ever-present glider of the binary arm is created by a gun of the corresponding period (repeated in the third and fourth arms).
The fuse arm creates a reflector (p8bouncer) and a seed for a pair of corderships so that the first bit read triggers the corderships in synchronized phase to allow annihilation (and reflection).
To trigger the fuse arm, we need a target for the arm gliders to be modified. This is what the pre-fuse does. It releases a glider, travels some distance, and releases a perpendicular lwss on collision course with the glider. The collision leaves behind debris (the target of the fuse arm) and launches two gliders into the spine. One of them hits its mirror image and creates a biblock, while the other triggers the fuse arm in the middle.
We already know what the fuse arm does, the binary arm creates ecca1 and triggers a meteor shower creating a reflector on the input signal path. When the arm's anchor stack is removed, ecca1 starts interpreting the input bits. The goal of the ecca1 arm is to clean up the west. It destroys the remnants of the dirty mwss creations and reconstructs the initial bliner configurations shifted 2 pixels to the east (we can't build anything on the spine due to symmetry, but we can modify the already presented content of the spine).
It also creates ecca2, the hive needed to transition to the one-dimensional state and the ship needed at the end of the tape cleaning.
Ecca1 finishes its work by destroying its reflector on the input signal path.
Ecca2 is responsible for cleaning up the east. It is built with a destruction seed (computation supported by the gSoD program), which means that one incoming glider on the correct path will cause the pattern to disappear. The destruction seed generates two gliders.
One of the goals of ecca2 is to create seeds of destruction of the reflectors on the input path - one destruction seed for the reflectors of ecca1 and one for the reflector, thus triggering the binary arm. The ship created by ecca1 near the spine converts a pair of cleaning mwss into a single glider, which triggers the destruction seed of ecca2. The exit gliders of ecca2 seed of destruction, are navigated by one time reflectors to the destruction seeds of the reflectors of ecca1 and the binary arm.
Ecca2 converts ecca1 into a ship (a disposable turner), which would play its role at the very end of the ship's period
(a slow destructive salvo combined with the trivial task of pslmake).
(the rest of the blinker of the binary arm stack is also destroyed by ecca2).
ECCA2 should also clean up the remains of the gun used by the binary arm (in the current version we stopped it with ecca1, but it would probably be equally or more efficient to stop it with ecca2)
(slow 2 salvo is used there and half honey farm to honey farm slow salvo move collection helps a lot in such design).
The most important task of ecca2 is to stop the tape reading mechanism and clean it up.
The salvo of synchronized gliders stops the GPSE90 and the corderabsorbers are assembled in time to stop the cordership pair
(as a tool a program was used that automatically combines a pre-calculated splitters and reflectors (consisting of at most two small objects) to create a given pair of synchronized parallel gliders).
The glider streams fired from the corderships do not stop at the same time, so the 3 escaping gliders are also stopped by the seed created by ecca2.
In order for ecca2 to create a seed to stop the GPSE90, it must clean up the irregularities of the GPSE90's trajectory debris. (destructive salvo calculated into a periodic pattern...). Similarly, the far-end cleanup converts the debris of the stalled GPSE90 into a periodic pattern.
Ecca2 must send corderfleets cleaning a periodic pattern (of arbitrary length). Therefore, it must create corderabsorbers on the other side (we chose corderabsorbers close, ships travelling from far).
(used a program to search for corderfleets cleaning compatible periodic patterns) ... the corderships were created using modern 11 cluster seeds (except for the one closest to the arm, where 12 cluster seeds were used to fit close to the arm)).
The corderfleet was also used to destroy the remnants of a pair of corderships.
The last task of ecca2 was to fire a salvo to create two mwss that would clean the blocks created during the tape reading (this would trigger a seed of ecca2 destroyal at the end).
The corderabsorber for the last cordership is modified and instead of annihilating with the cordership it emits a perpendicular glider that hits the boat from the ECCA1 conversion to bounce to the behive and converts it into a one-dimensional pattern, starting a new generation.
The ECCA2 compiler used agnosticised lane phase recipes and chose the optimal route from the options (shortening the tape as much as possible). This optimization was not done in ECCA1, binary or fuse arm.
Here is Claude's translation/ explanation. No idea if it's correct, read at your own risk:
The Basic Idea:
The project builds a spaceship using 4 different "construction arms" that work like automated assembly lines, each building the next one in sequence.
The Four Arms:
Fuse Arm (First): Uses oscillating "blinker" patterns that can be triggered to create moving signals. By carefully arranging blinkers and triggering them, it can generate gliders (small moving patterns) at precise locations and times.
Binary Arm (Second): Uses pairs of synchronized gliders where the presence or absence of one glider modifies the outcome. It can build patterns by positioning elements closer or farther and generating perpendicular gliders.
ECCA1 (Third Arm): An "extreme compression construction arm" that interprets incoming bits like a programming language. Each instruction specifies which glider to emit. It's very efficient, needing only 7-8 bits per glider. Its job is to "clean up the west" - destroy debris and rebuild patterns.
ECCA2 (Fourth Arm): Similar to ECCA1 but even more efficient. It "cleans up the east," stops the reading mechanism, and prepares the pattern to transition into its next generation.
How It Works:
Information is stored as blinkers along a central "spine"
Gliders read this information like reading a tape
Each arm builds the next arm and performs cleanup tasks
The whole pattern eventually self-destructs in a controlled way and rebuilds itself shifted forward, creating movement
The Result:
A self-contained pattern that reads its own "genetic code," builds construction machinery, uses that machinery to rebuild itself one step forward, then destroys the old version - essentially a one-dimensional self-replicating machine.
If the first Star Trek episodes were written today, they could have very well used GoL terminology as technobabble. The depth of the GoL community lingo always amazes me, as an outsider
Me: oh cool, this is interesting, I don’t quite understand what exactly that means, let me read the thread to learn more…
The thread: > Replacing ECCA1 by version with step after the direction change could save something like 1% of the ecca1 bits size. Compiling agnosticized program instead of fixed lane program by ecca1 could save something like 1% as well (just guesses). Build of smaller ECCA1 would shorten binary portion, but it would be hardly seen in the ship size.
> Using agnosticized recipe in the fuse portion would definitely reduce its size. Better cordership seed and better salvo for gpse90 would help…
Dear lord I had no idea there’s this much jargon in the game of life community. Gonna be reading the wiki for hours
Their free book "Conway’s Game of Life: Mathematics and Construction" is a great starting point - https://conwaylife.com/book/conway_life_book.pdf
That's because it's not "game of life jargon", it's "cellular automata" jargon. Which is a field of math and comes along with a bunch of math jargon from related fields.
I searched several of these terms and they are all specifically jargon of game of life enthusiasts, (i.e. search reaults are all on fansites related to game of life) not general cellular automata jargon.
mmmh I don't think so. I've read several papers on cellular automata and I don't recognize the terms
Once a year or so I find myself on those forums and I'm always astounded how many people there are that dedicate massive amounts of time and brain power to this.
So it starts as a line, explodes into a huge 2D complex mess, and eventually, after many generation, returns to form the same 3.7B cells long line?
That's kind of amazing. I wish someone unpacked the units of abstraction/compilation that must surely exist here.
Surely they aren't developing this with 1 or 0 as the abstraction level!
See here: https://conwaylife.com/forums/viewtopic.php?f=2&t=2040&start...
It’s also a relatively sparse line, as the number of live cells is less than a hundredth of the line’s extent: https://conwaylife.com/wiki/Unidimensional_spaceship_1
> Work started in 2016 and was completed on December 1, 2025.
Almost 10 years of development.
How many steps is the period? How far does it travel in that period? What direction does it go? Does it clean up after itself?
Only about 1.5% of the human genome is protein coding. The human genome is about 3 billion base pairs long.
Game of life indeed!
[flagged]
> I asked AI to explain it to me,
We all know how to do that, but that's not why were here.
I’m not sure where our guidelines/norms are on this kind of thing, but I get the sense that most of us feel very capable of pasting articles into LLMs ourselves.
What we’re less capable of—and the reason we look to each other here instead—is distinguishing where the LLM’s errors or misinterpretations lie. The gross mistakes are often easy enough to spot, but the subtle misstatements get masked by its overconfidence.
Luckily for us, a lot of the same people actually doing the work on the stuff we care about tend to hang out around here. And often, they’re kind enough to duck in and share.
Thank you in any case for being upfront about it. It’s just that it’d be a shame and a real loss if the slop noise came to drown out the signal here.
Reading a long explanation on a GoL forum is a great way to experience what it’s like for my spouse to listen to my work conversations on Zoom. This jargon is fantastic.
More or less like this?
https://www.youtube.com/watch?v=eMJk4y9NGvE
Two of the most fascinating open questions about the Game of Life are in my opinion:
1. What is the behavior of Conway's Game of Life when the initial position is random? Paraphrasing Boris Bukh's comment on the post linked below, the Game of Life supports self-replication and is Turing-complete, and therefore can support arbitrarily intelligent programs. So, will a random initial position (tend to) be filled with super-intelligent life forms, or will the chaos reign?
There exist uncountably infinitely many particular initial configurations out of which a random one may be drawn, which makes this more difficult (a particular infinite grid configuration can be represented as the binary digits (fractional part) of a real number, spiraling outwards from a given center coordinate cell: 0.0000... represents an empty infinite grid, 0.1111... a fully alive infinite grid).
https://mathoverflow.net/questions/132402/conways-game-of-li...
2. Relatedly, does a superstable configuration exist? One that continues to exist despite any possible external interference pattern on its border? Perhaps even an expanding one?
https://mathoverflow.net/questions/132687/is-there-any-super...
One problem is that, even though it is turing-complete, many practical operations are very difficult. Patterns tend towards chaos and they tend towards fading out, which are not good properties for useful computation. Simply moving information from one part of the grid to another requires complex structures like spaceships.
You might have better luck with other variants. Reversible cellular automata have a sort of 'conservation of mass' where cells act more like particles. Continuous cellular automata (like Lenia) have less chaotic behavior. Neural cellular automata can be trained with gradient descent.
Is there a visualization of the glider in the thread? Would love to see how it evolves with one dimension being time.
My understanding (which could be wildly wrong, I only skimmed the thread) is that it's running in a standard 2-dimensional Game of Life grid, it just happens to start out as a 1x3.7B cell line.
After the first step it isn't 1D any more, so I don't think that visualization is possible
It's possible. It'd just be a 3D visualization and more importantly, stupendously huge. If each cell was a cubic millimeter, the shape would be 3700km wide, and stretch 1/3rd of the way to the moon.
Notably it only fits within a 1 cell high bounding box during at least one of its phases, not all.
I'm not a GoLtician myself but I don't think that would be possible under the "standard" rules anyway, except the trivial case of stasis/death.
I'm really charmed by the linked thread and all the passion and work it belies. Congrats to those involved!
Why do you think it would not be possible?
I love it that there are people obsessed enough to spend their time on this and our society can support it.
1D spaceship*
glider is a specific spaceship, but name for "moving pattern" is spaceship
Their own wiki points out they're sometimes used interchangably.
https://conwaylife.com/wiki/Spaceship
Hah, and a forum bug further down in the thread:
> Seems there is a bug in the forum, when more people write a post at the same time the post sometimes vanishes.
“History Doesn't Repeat Itself, but It Often Rhymes” – Mark Twain
Looking forward to the impending AI and crypto crash and have people run GoL simulations on expensive computer systems like it's 1972 again.
Off-topic, but like a lot of quotes attributed to Twain, there’s no evidence he said that.
https://quoteinvestigator.com/2014/01/12/history-rhymes/
Can someone please ELI5 what this means? Thanks in advance.
Someone figured out how to create a glider that starts and ends as a long string of cells on a single line. Gliders are figures in the game of life that move themselves in a direction by repeated patterns that result in movement. For more game of life/glider context you can read the pretty decent Wikipedia articles:
Conway's game of life: https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
Gliders: https://en.wikipedia.org/wiki/Glider_(Conway%27s_Game_of_Lif...
As noted by others, the title is mistaken; this is a spaceship, not a glider. (As explained in the Wikipedia article, "glider" refers to a specific 5-cell pattern discovered very early on.)
> So finally 2/133076755768 ship of starting bounding box 3707300605x1 is here
My understanding is that 2/133076755768 is the speed, in (number of cells translated) / (number of generations to repeat).
spaceship*
glider is one specific spaceship, but name for moving patterns is spaceship
Thank you ^_^
This seems like a great task as a test for AI.
The result is easily verify-able, yet the techniques to design such a glider are very complex and some might not have been discovered yet.
It's already being done. Has been done for decades now. Definitely wouldn't be a good use of an LLM-type model if that's what you're proposing
If you look at the placement of Journal of Cellular Automata in SciMago's Shape of Science visualization[0] you'll see that it's completely surrounded by machine learning/AI journals
[0] https://www.scimagojr.com/shapeofscience/
Sometimes I feel a deep sense of loss of the old web that grew up with -full of niche interests, unashamedly earnest and rich in subcultures- has been lost in a sea of corporate slop and clickbait social media.
Then occasionally I come across something like this and it feels like all is not lost. Conway's GoL was one of the first C programmes I ever wrote and I've long been distantly fascinated by cellular automata but I had no idea that there was such a depth of research (work, experimentation, collaboration? how do you even describe this kind of collective endeavour?) into GoL lurking out there all these years.
RIP John Conway, a victim of Covid.
What are the rules in 1d ?
It only starts out 1-dimensionally, it continues to evolve on a standard GoL grid.
Then, importantly, it collapses itself back down to a 1-dimensional copy of its starting representation, but translated.
Specifically, after 133_076_755_768 steps, the 1-dimensional pattern reoccurs translated by two pixels. On skimming the thread I haven't determined if that shift is parallel or perpendicular to the line.
I think it has to be parallel by symmetry.
Can it leave other bits behind after it moves?
Wow this seems very interesting! Can we get a TLDR of how this was achieved?
While I understand very little of it, it is still very enjoyable to read the details further in the thread at https://conwaylife.com/forums/viewtopic.php?&p=222136#p22221...
>>>
Unidimensional spaceship can be interpreted as a demonstration of the progress of recent years in slow salvo technology and the various arms that use it.
The project uses 4 construction arms, with the last three sharing principles with the arms used in the RCT15 project. The first arm is newly invented just for this case. I was not part of the community at the time the principles of the first two arms were studied, but let me describe them anyway.
The one line restriction limit us to using blinkers as the basis of the first arm. Interestingly, a small perturbation at the end of some blinker configuration makes the pattern unstable, and several blinker patterns allow the perturbation "fuse" to move in a controlled manner. Various configurations have been discovered that leave no debris but move at different speeds. Some configurations have been found that produce backward-firing mwss (and leave debris), head-on collisions of mwss that transform them into gliders for both glider colors. By combining these configurations, we can trigger a fusion in the middle of a carefully chosen arrangement of blinkers that would synchronize the mwss collisions at the desired time parity at a prescribed x-coordinate and generate a glider with a prescribed phase and trajectory, so that such an arm could create any p2 recipe.
The second arm used is a binary arm, where a pair of synchronized gliders on the same trajectories are used, with one glider always present and the presence of the other gliders allowing modification of the resulting configuration. Careful study of the results of various words using letters "1" and "2" (indicating the presence of the second glider) led to the discovery of specific modifications of the target "anchor" configuration.
Some of them allow you to move the "head" of the anchor stack to move closer/farther from the base of the arm. Some sequences will generate a perpendicular glider. Not all mod 8 phases and colors are known, but with careful "head positioning" any p8 recipe could be built with such an arm. The program used for the translation only used single blinker anchor technology, which produces a glider for a cost of around 100 bits ("letters"). The agnosticisation salvas of the p8 recipe to use only the p1/p2 constraints on the glider phases (when possible) greatly reduces the number of bits required. Alternative glider paths also help, leading to the same stable configurations during a slow salvas. Currently, there is an alternative method with around 80 bits per glider using 4 different anchors deep in the "arm target stack". The code could be improved by some form of dynamic programming by compiling the salvo from the parts emitting gliders closest to the arm to the gliders further away from the arm, but there was no need to complete the project.
The third and fourth arms are extreme compression construction arms "ecca", where a programming language interpreter is created and individual incoming letters are interpreted as instructions specifying which phase (mod 2) and line of glider to emit.
We have achieved an optimal encoding that requires about 7-8 bits to emit a typical slow p2 salvo of gliders.
The instruction set includes a move direction change option, move4 (repeated), move2, move1, color option, phase option. Stopping the move4 loop results in a glider being fired "near" the current arm position after a defined number of letters. The third arm uses exactly this set of options, while the fourth arm executes move1 after a change of direction, further increasing its efficiency. The fourth arm uses "yellow lane" filtering technology, which allows its components to be recycled, resulting in a more compact and less expensive design. On the contrary ecca1 is built as p1 pattern what allows selecting less expensive options during the build by the binary arm (at few places where p8 restriction would be required in ecca2 build). The arms are capable of firing gliders with 4 combinations of phase mode 8 and color (all four combinations of phase mode 2 and color). This is perfectly fine for slow salvos with a p2 restriction, but building p8 salvos requires limiting the salvos to use only a limited set of "signature" color combinations of glider phases.
This led to a modification of the psamake program (transforming "neo" Spartan configurations for slow salvos that are built from a single block). When a bespoke subsalvo builds a p8 pattern (initial call by a single glider), a 0 degree one time turner prefix is optionally allowed for a phase/color correction. Similarly, p2 salvos are transformed to the required p8 phases corresponding to the signature.
There are several other prerequisites for building a ship. We should implement a storage where the bits to be fed into the binary arm and later into the ecca1 and ecca2 arms are encoded. Fortunately, a slow salvo of 8 gliders fired symmetrically into the central "spine" of the track from both sides (the ship cannot lose symmetry) will create 4 blocks near the spine if there was nothing there, or move the blinker from its given position by 2 pixels (east) emitting glider back.
There are a few more requirements to build the ship. We should implement a storege of bits that will be fed into the binary arm and later into the ECCA1 and ECCA2 arms. Fortunately, a slow salvo of 8 gliders fired symmetrically into the central “spine” track from both sides (the ship cannot lose symmetry) will create 4 blocks near the spine if there is nothing there, or move the blinker from its current position by 2 pixels (east) emitting glider backward.
The fuse arm fires 8 90 degree glider producing switch engines “GPSE90” that fire the slow salvo and convert the blinkers on the spine into a traveling signal.
The signal is then fed into the binary arm by a pair of gliders firing the gliders back. One of the gliders is reflected so that they annihilate on impact. The glider signal from the tape annihilates the glider from one stream (negative signal), so the reflected glider from the other stream is not annihilated at the start of the arm. The ever-present glider of the binary arm is created by a gun of the corresponding period (repeated in the third and fourth arms).
The fuse arm creates a reflector (p8bouncer) and a seed for a pair of corderships so that the first bit read triggers the corderships in synchronized phase to allow annihilation (and reflection).
To trigger the fuse arm, we need a target for the arm gliders to be modified. This is what the pre-fuse does. It releases a glider, travels some distance, and releases a perpendicular lwss on collision course with the glider. The collision leaves behind debris (the target of the fuse arm) and launches two gliders into the spine. One of them hits its mirror image and creates a biblock, while the other triggers the fuse arm in the middle.
We already know what the fuse arm does, the binary arm creates ecca1 and triggers a meteor shower creating a reflector on the input signal path. When the arm's anchor stack is removed, ecca1 starts interpreting the input bits. The goal of the ecca1 arm is to clean up the west. It destroys the remnants of the dirty mwss creations and reconstructs the initial bliner configurations shifted 2 pixels to the east (we can't build anything on the spine due to symmetry, but we can modify the already presented content of the spine). It also creates ecca2, the hive needed to transition to the one-dimensional state and the ship needed at the end of the tape cleaning.
Ecca1 finishes its work by destroying its reflector on the input signal path.
Ecca2 is responsible for cleaning up the east. It is built with a destruction seed (computation supported by the gSoD program), which means that one incoming glider on the correct path will cause the pattern to disappear. The destruction seed generates two gliders. One of the goals of ecca2 is to create seeds of destruction of the reflectors on the input path - one destruction seed for the reflectors of ecca1 and one for the reflector, thus triggering the binary arm. The ship created by ecca1 near the spine converts a pair of cleaning mwss into a single glider, which triggers the destruction seed of ecca2. The exit gliders of ecca2 seed of destruction, are navigated by one time reflectors to the destruction seeds of the reflectors of ecca1 and the binary arm.
Ecca2 converts ecca1 into a ship (a disposable turner), which would play its role at the very end of the ship's period (a slow destructive salvo combined with the trivial task of pslmake). (the rest of the blinker of the binary arm stack is also destroyed by ecca2).
ECCA2 should also clean up the remains of the gun used by the binary arm (in the current version we stopped it with ecca1, but it would probably be equally or more efficient to stop it with ecca2) (slow 2 salvo is used there and half honey farm to honey farm slow salvo move collection helps a lot in such design).
The most important task of ecca2 is to stop the tape reading mechanism and clean it up. The salvo of synchronized gliders stops the GPSE90 and the corderabsorbers are assembled in time to stop the cordership pair (as a tool a program was used that automatically combines a pre-calculated splitters and reflectors (consisting of at most two small objects) to create a given pair of synchronized parallel gliders). The glider streams fired from the corderships do not stop at the same time, so the 3 escaping gliders are also stopped by the seed created by ecca2. In order for ecca2 to create a seed to stop the GPSE90, it must clean up the irregularities of the GPSE90's trajectory debris. (destructive salvo calculated into a periodic pattern...). Similarly, the far-end cleanup converts the debris of the stalled GPSE90 into a periodic pattern. Ecca2 must send corderfleets cleaning a periodic pattern (of arbitrary length). Therefore, it must create corderabsorbers on the other side (we chose corderabsorbers close, ships travelling from far). (used a program to search for corderfleets cleaning compatible periodic patterns) ... the corderships were created using modern 11 cluster seeds (except for the one closest to the arm, where 12 cluster seeds were used to fit close to the arm)).
The corderfleet was also used to destroy the remnants of a pair of corderships. The last task of ecca2 was to fire a salvo to create two mwss that would clean the blocks created during the tape reading (this would trigger a seed of ecca2 destroyal at the end).
The corderabsorber for the last cordership is modified and instead of annihilating with the cordership it emits a perpendicular glider that hits the boat from the ECCA1 conversion to bounce to the behive and converts it into a one-dimensional pattern, starting a new generation.
The ECCA2 compiler used agnosticised lane phase recipes and chose the optimal route from the options (shortening the tape as much as possible). This optimization was not done in ECCA1, binary or fuse arm.
Here is Claude's translation/ explanation. No idea if it's correct, read at your own risk:
The Basic Idea:
The project builds a spaceship using 4 different "construction arms" that work like automated assembly lines, each building the next one in sequence.
The Four Arms:
Fuse Arm (First): Uses oscillating "blinker" patterns that can be triggered to create moving signals. By carefully arranging blinkers and triggering them, it can generate gliders (small moving patterns) at precise locations and times.
Binary Arm (Second): Uses pairs of synchronized gliders where the presence or absence of one glider modifies the outcome. It can build patterns by positioning elements closer or farther and generating perpendicular gliders.
ECCA1 (Third Arm): An "extreme compression construction arm" that interprets incoming bits like a programming language. Each instruction specifies which glider to emit. It's very efficient, needing only 7-8 bits per glider. Its job is to "clean up the west" - destroy debris and rebuild patterns.
ECCA2 (Fourth Arm): Similar to ECCA1 but even more efficient. It "cleans up the east," stops the reading mechanism, and prepares the pattern to transition into its next generation.
How It Works:
Information is stored as blinkers along a central "spine" Gliders read this information like reading a tape Each arm builds the next arm and performs cleanup tasks The whole pattern eventually self-destructs in a controlled way and rebuilds itself shifted forward, creating movement
The Result:
A self-contained pattern that reads its own "genetic code," builds construction machinery, uses that machinery to rebuild itself one step forward, then destroys the old version - essentially a one-dimensional self-replicating machine.
Pasting AI garbage you don't understand is worse than useless.
If the first Star Trek episodes were written today, they could have very well used GoL terminology as technobabble. The depth of the GoL community lingo always amazes me, as an outsider
[dead]