
Show HN: Ecosim – A cellular ecosystem simulator toy for Linux written in C - connor-brooks
https://github.com/connor-brooks/ecosim
======
api
Reminds me of something I wrote years ago:

[https://github.com/adamierymenko/nanopond](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).

~~~
connor-brooks
Nice, this is so cool! I had a few line-type creatures wriggling around at
first and then a huge population explosion occurred and a swarm started
filling the screen.

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

~~~
connor-brooks
I'm planning to do this once I get my hands on a video capture card! Thanks
for the advice :)

~~~
movedx
Video capture card? Doesn't it run on the desktop? Just use OBS (Open
Broadcast Software) to capture the window, friend. Much simpler.

------
sandov
For some reason it complained about GLFW_TRUE not being declared, but I just
replaced it in the source code with a literal 1 and then it worked.

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

~~~
connor-brooks
Currently having difficulties getting it running on macOS, and gdb doesn't
seem to play nice with Catalina

~~~
sliken
Doesn't work on ubuntu 19.10 either.

gcc -c main.c gcc -g3 logger.o quadtree.o graphics.o utils.o agents.o input.o
main.o -o ecosim -lGL -lm -lglfw -lGLEW $ ./ecosim Segmentation fault (core
dumped)

------
ubadair
Very cool. I have dreamed of building something similar. I would be interested
in these modifications:

1\. Change living/non-living distinction of food to two different dimensions,
shared by living and non living food alike: * Composition - arbitrary bits to
match against a consuming organism's diet * Defense - arbitrary bits to match
against consuming organism's capabilities, might be a function of energy level
for living food

2\. Organisms leave behind waste as part of eating and/or moving. Waste left
behind is food for other organisms

This might allow for the rise of symbiosis and multicellular organisms

~~~
connor-brooks
These are great ideas. I was looking for ways to facilitate symbiosis. Thank
you :)

------
RawChicken
Anyone interested on this might also be interested in an mobile app called
"Cell Lab: Evolution Sandbox" [1], which does a good take on a cell simulation
"game".

[1] [https://www.cell-lab.net/](https://www.cell-lab.net/)

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

~~~
chaoticmass
I am getting a Segmentation fault under Debian Stretch.

~~~
connor-brooks
Uh oh, what graphics card / driver are you using?

~~~
sliken
Not the OP, but it crashed with ubuntu 19.10 with a GTX1070 with the default
ubuntu nvidia binary blob: i nvidia-driver-390 - NVIDIA driver metapackage

Maybe the code is incompatible with libglew2.1?

When I run: $ ./ecosim Segmentation fault (core dumped)

I see a window map for an instant before the seg fault.

------
Icathian
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](https://en.m.wikipedia.org/wiki/EcoSim)

~~~
connor-brooks
Thanks! Oops, maybe not the best choice of name haha

------
airstrike
Very cool! I wonder if anyone has done something similar but for people and
companies in an economy... it's my dream pet project, but I've never even
gotten around to researching where to begin.

------
bch
How would you like to license this code?

------
kazinator
Very decent, readable coding style.

------
DonHopkins
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](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](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...](https://github.com/SimHacker/CAM6/blob/master/javascript/CAM6.js#L3331)

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 |= 0x01;
                                        }
                                    } else {
                                        if ((sum8 != 5) && (sum8 != 6)) {
                                            cell |= 0x01;
                                        }
                                    }
                                } else {
                                    // Brain
                                    cell |= (c << 1) & 2;
                                    if ((c & 3) == 0) {
                                        if (sum8 == 2) {
                                            cell |= 1;
                                        }
                                    }
                                }
    

The CelLab user's guide and Rudy Rucker's recounting of the origins of CelLab
and his experience with Margolus and Toffoli's CAM6 is especially delightful.

[https://www.fourmilab.ch/cellab/manual/](https://www.fourmilab.ch/cellab/manual/)

[https://www.fourmilab.ch/cellab/manual/chap5.html](https://www.fourmilab.ch/cellab/manual/chap5.html)

Bennett shows me another pattern, one that looks like boiling red cottage
cheese, and then he takes me across the Charles River to the MIT Laboratory of
Computer Science. In the basement is an exuberant French scientist named
Gérard Vichniac. He and an associate are watching a small rectangular dot-
pattern in the center of their terminal's screen. The pattern is mostly white,
with a small amount of red in it. The edges keep folding in on each other as
the pattern evolves according to some simple rule which Vichniac made up. He
calls it an “Ising Model,” but it looks like an electronic kaleidoscope. “This
pattern started as a red square,” Vichniac tells me. “The rule is reversible,
so we know that eventually the red square must come back. We've been watching
it for eighty thousand steps now”.

Upstairs from Vichniac are two equally cheerful cellular automata specialists,
Norman Margolus and Tommaso Toffoli. There's another journalist there, a guy
from Rolling Stone.[Footnote] Cellular automata are hot. I introduce myself
and sit down to watch the demonstration. Right now there's a central cloud of
dots, with square little patterns flying out of it. On the sides of each of
the square patterns are individual pixels that pump up and down.

“Look at the critters, Tom,” says Margolus. “They look like rowers, don't
they?”[Footnote]

“Show him the square rock,” says Toffoli.

Margolus clears the screen and keys a big red square into the center. The
square expands out to the edges of the screen and bounces back. As the
bouncing continues, the patterns interfere and form complex checkerboard
patterns, enough patterns in thirty seconds to have made a respectable one-man
Op-Art show in the 1960s.

Toffoli pries Margolus away from the controls and takes over. “Now we do the
square rock in the toroidal pond again, but this time we add a heat-bath, a
cloud of random gas in the background.”

The background fills with darting dots, and Toffoli keys another big red
square into the center. This time the waves are smooth and roughly circular,
much like real waves in a real pond. We try it with two squares and get
interference patterns. Toffoli is pleased. He says that this shows how simple
physics really is.

[...]

After watching the CAM in operation at Margolus's office, I am sure the thing
will be a hit. Just as the Moog synthesizer changed the sound of music,
cellular automata will change the look of video.

I tell this to Toffoli and Margolus, and they look unconcerned. What they care
most deeply about is science, about Edward Fredkin's vision of explaining the
world in terms of cellular automata and information mechanics. Margolus talks
about computer hackers, and how a successful program is called “a good hack.”
As the unbelievably bizarre cellular automata images flash by on his screen,
Margolus leans back in his chair and smiles slyly. And then he tells me his
conception of the world we live in.

“The universe is a good hack.”

[...]

Margolus and Toffoli's CAM-6 board was finally coming into production around
then, and I got the Department to order one. The company making the boards was
Systems Concepts of San Francisco; I think they cost $1500. We put our order
in, and I started phoning Systems Concepts up and asking them when I was going
to get my board. By then I'd gotten a copy of Margolus and Toffoli's book,
Cellular Automata Machines, and I was itching to start playing with the board.
And still it didn't come. Finally I told System Concepts that SJSU was going
to have to cancel the purchase order. The next week they sent the board. By
now it was August, 1987.

The packaging of the board was kind of incredible. It came naked, all by
itself, in a plastic bag in a small box of styrofoam peanuts. No cables, no
software, no documentation. Just a three inch by twelve inch rectangle of
plastic—actually two rectangles one on top of the other—completely covered
with computer chips. There were two sockets at one end. I called Systems
Concepts again, and they sent me a few pages of documentation. You were
supposed to put a cable running your graphics card's output into the CAM-6
board, and then plug your monitor cable into the CAM-6's other socket. No,
Systems Concepts didn't have any cables, they were waiting for a special kind
of cable from Asia. So Steve Ware, one of the SJSU Math&CS Department techs,
made me a cable. All I needed then was the software to drive the board, and as
soon as I phoned Toffoli he sent me a copy.

Starting to write programs for the CAM-6 took a little bit of time because the
language it uses is Forth. This is an offbeat computer language that uses
reverse Polish notation. Once you get used to it, Forth is very clean and
nice, but it makes you worry about things you shouldn't really have to worry
about. But, hey, if I needed to know Forth to see cellular automata, then by
God I'd know Forth. I picked it up fast and spent the next four or five months
hacking the CAM-6.

------
rogerclark
ultra sick project dude!

~~~
connor-brooks
Thanks! :)

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

