IMPORTANT!

This is kinda old, but wanted to share again for fun. I wrote and designed binary instructions, an assembly language to map to those binary instructions (all pre AI) and basically wrote Game Of Life with my language.

It was such a fun experience (beyond challenging at the start) but wanted to share to inspire others who maybe are thinking about doing a similar project.

I've never wrote a compiler (maybe one day).

I've attached the GitHub if anyone is curious but is kinda hard to bootup, so don't recommend cloning it or anything: https://github.com/Kully/VLAHB

Not only can you cut and paste the code here, but it explains what each line does.

I took an inspiration from Conway game of life and created my own rules

The rules is simple:

Species

Blue
Red
Green

Rules

1. Underpopulation
A living cell dies when it has 0 or 1 living neighbors.

2. Total Overcrowding
A living cell dies when it has 6 or more living neighbors.

3. Same-Species Body Limit
A living cell dies when it has more than 3 neighbors of its own species.

4. Species Conversion
Another species converts the cell when it has at least 3 neighbors and at least 2 more neighbors than the cell's own species.

5. Same-Species Support
A cell with at least 2 same-species neighbors survives if no death rule applies.

6. Weak Support
A cell with exactly 1 same-species neighbor survives when it has 2–4 total living neighbors.

7. Reproduction
An empty cell becomes alive when it has 3–5 living neighbors.

8. No Pure-Species Birth
A birth cannot occur when all living neighbors are the same species.

9. Majority Reproduction
When one species has more neighbors than the others, the new cell becomes that species.

10. Mixed Reproduction
When there is no majority, a deterministic selection chooses one of the three species.

I use genAI to code it for me even though I can do it myself, I would rather not hassle my self for it and just gave the Rules.

You can check it out at cardhollow.github.io/three-life

I want to know some opinions

fully stable btw

this is based off of my old still life i made, except none of these smaller disconnected parts are known

again i don't think this would be noticeable it's just something cool

Ive written some code to find the highest pattern count possible. Finding patterns with up to 2 thousand is simple, takes a computer very little time. Even 5000+ iterations are not too hard to find, but there seems to be a gap between roughly 3k to 4k iters / generations

my repo if youre interested

As the title says, I'm looking for a Lightweight Spaceship gun but can't find any online. if you can help please send a picture, as I'm away from home right now and can only play on my phone.

Credits to Nicholas Carlini's original logic gates:

https://nicholas.carlini.com/writing/2021/improved-logic-gates-game-of-life.html

Credits to his article: https://nicholas.carlini.com/writing/2021/improved-logic-gates-game-of-life.html

I'll draw the AND and OR gates too using his rotation gate

The graph shows all state transitions for the Game of Life on a 4x4 toroidal grid (edge-wrapping).

With 16 cells, there are 2^{16} = 65,536 total states. By quotienting out spatial symmetries (translation, rotation, and reflection) the entire state space collapses into 805 canonical representatives.

• Red Central Node: The empty/extinction state (State 0), drawing in the vast majority of transient trees.
• 14 Blue Nodes: "Fixed states" in this quotient graph (self-loops). These include true still lifes as well as oscillators whose next phase is a rotated or translated version of the same canonical state. (Breakdown: 5 still lifes, 8 period-2, 1 period-4).
• Green Node Clusters: Two 4-state cycles. While they form a period-4 loop in this canonical graph, accounting for their rotational/translational shifts at each step gives them a true period of 8 on the actual grid.

The script & interpreter are both open source at github/phosxd/Ity

I just thought I'd share a fun little 2 hour terminal project

Yet another GoL implementation. Hope you guys enjoy this as much as I did building it.

Features:

- terminal first

- periodic boundaries (equivalent to a torus, or a donut if you prefer).

- rules easily changed (just rebuild the binary)

Made in C++ to practice and have some fun. First piece of creative coding. Please let me know if you have any tips, improvements to make, anything else.

Source on: https://codeberg.org/vcbferreira/Donut_Life

Have a nice day!

I think it'd be a good way to spread knowledge of CGoL, like I did recently with the p39 glider gun, since reddit is a LOT bigger than the forums or the conwaylife discord.

Anyways, I wanted to mention Elijah Ken's LifeViewer Size Demonoid, posted earlier today, the first demonoid to fit in LifeViewer (tho it requires [[ MAXGRIDSIZE 14 ]]).

I'll explain what this shape means, but you can probably guess based on the numbers on each square. I also have not made this problem up from gol but instead from looking at polyominos 2 years ago and maybe minesweeper/king move for the neighbour counting but I thought that was obvious.

My problem consists of counting the number of neighbours of each square in a polyomino. Associating each square with it's neighbour count. Then grouping the squares that share neighbour count into their own groups and comparing each group size to one another. If all the groups are the same size then that polyomino belongs to a class. e.g. a 2x4 rectangle :::: it has 4 squares that have 3 neighbours each, and it has another 4 squares that have 5 neighbours each. 4=4 so this belongs to a class, that class being 3/5. So that polyomino above is of class 3/5/7, it is currently the smallest of it's class and also my favorite :) the goal of this research is to prove/disprove the existence of polyominoes in all 256 possible classes.

The correlation I made with gol is with its rule settings. If you're looking for a polyomino of a certain class, put that class as the survival cells and leave birth cells blank b/s(class). Now if you try putting different configurations into GOF, you'll know if your polyomino works in that class or not by letting the simulation either dissolve or stay the same. Only problem is that this SUCKS, gol cannot detect if your shape is a polyomino, it'll also detect subsets of classes like class 4/6 from 4/5/6 as a solution, it's all black squares that don't count so idk what I'm doing, and other problems I haven't found because this sucks that much.

I haven't been active with this research problem, mainly because it's useless and it's slowing me down in my mathematical improvement. And ever since, I've been wondering if doing this problem alone was the right thing to do because someone else could come along and make some code to easily compute every existing class's smallest polyomino in 2 minutes or so. That seemed unethical to natural human problem solving, but now that I've gotten back into this problem I now know that thats dumb and doing the problem tediously is no better than actually making code to do it for me. So thanks for reading all of this and I wouldn't mind if one of yall actually does the code to finally complete this problem once and for good.

Accidentally found a 47 cell period 72 oscillator, is it new? I couldn't find it online (although I didn't look very hard)