Hacker News new | past | comments | ask | show | jobs | submit login
Show HN: Ecosim – A cellular ecosystem simulator toy for Linux written in C (github.com/connor-brooks)
150 points by connor-brooks on Feb 27, 2020 | hide | past | favorite | 29 comments



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


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.


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.


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


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


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.


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.


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


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)


Try LLDB; Apple keeps breaking GDB.


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


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


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/


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


Interesting. What distribution are you using? On Debian it has been working fine, however on macOS I also encounter the glDrawElements issue. Still working on that.


I'm on Arch running the latest proprietary nvidia drivers.


I am getting a Segmentation fault under Debian Stretch.


Likewise on Ubuntu 19.10. Running an NVIDIA GTX 950 on nvidia-driver-430 (proprietary).


Uh oh, what graphics card / driver are you using?


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.


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


Thanks! Oops, maybe not the best choice of name haha


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.


How would you like to license this code?


Very decent, readable coding style.


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


ultra sick project dude!


Thanks! :)


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




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: