Show HN: Ecosim – A cellular ecosystem simulator toy for Linux written in C (github.com)

ultra sick project dude!

Very cool! However, I don't see why this has to be so specific for Linux from when by judging from the libraries used it can be also compiled for MingW, macOS, Free/Open/NetBSD, QNX and even surprising Haiku.

But a very interesting project nevertheless.

It looks pretty interesting but unfortunately I'm unable to run the demo, getting a crash in glDrawElements which is sort of outside of my scope to address. As a side note the debug symbols flag doesn't get passed to individual C files so the binary ends up without debugging symbols (as a workaround I moved the -g3 flag to CC variable instead).

This seems very cool. I would recommend including an animated gif or link to a YouTube video showing the results of the simulation under a variety of settings/parameters. Also, this would probably get a lot more traction if it used web technologies WASM and webgl. Would be cool to combine this with an evolutionary algorithm similar to the Scriptbots project by Karpathy.

Seems like a really cool project.

If you're at all concerned with keeping it reasonably easy to find, you may want to know that the name Ecosim is in use by software for simulation modeling of trophic energy flows in ecosystems.

https://en.m.wikipedia.org/wiki/EcoSim

Reminds me of something I wrote years ago:

https://github.com/adamierymenko/nanopond

Ecosim has prettier graphics and seems more high level and concerned with ecology, while nanopond is more about just open ended program evolution (including the rise of self-replicators ex nihilo... it starts by just generating totally random programs).

Does it run under OpenGL 2.1? My laptop is a bit... obsolete.

Here's another ecology oriented cellular automata rule called ECOLIBRA, a cross between LIFE, BRAIN (and optionally ANNEAL on the bit plane that determines water/land), from John Walker's and Rudy Rucker's classic CelLab (which Autodesk originally published as a PC application, but John Walker has ported to JavaScript):

https://www.fourmilab.ch/cellab/manual/rules.html#EcoLiBra

>ECOLIBRA

>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.

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...

Here are the guts of the rule (omitting the heat diffusion layer calculation):

                            var cell = 0;

                            var sum9Anneal =
                                    ((nw & 0x04) + (n & 0x04) + (ne & 0x04) +
                                     (w  & 0x04) + (c & 0x04) + (e  & 0x04) +
                                     (sw & 0x04) + (s & 0x04) + (se & 0x04)) >> 2;
                            var anneal =
                                    ((sum9Anneal > 5) || (sum9Anneal == 4)) ? 4 : 0;

                            cell |= anneal;

                            var sum8 =
                                    (nw & 1) + (n & 1) + (ne & 1) +
                                    (w  & 1) +           (e  & 1) +
                                    (sw & 1) + (s & 1) + (se & 1);

                            if (anneal) {
                                // Anti-Life
                                cell |= ((c & 1) << 1);
                                if (c & 1) {
                                    if (sum8 != 5) {
                                        cell |= ...