Machines already organic

We are witnessing the emergence of forms of life that transcend the biological. What we thought were mere simulations becomes reality: machines are beginning to acquire metabolism and autonomy.

Living pixels: my first organic automata

In 1970, John Conway invented a small computer program, the Game of Life, a “cellular automaton” whose rules are very simple: a living cell survives with two or three neighbors; a dead cell is reborn with exactly three neighbors; all others die or remain dead.

In the early 1980s, the Game of Life was a program that spread on personal microcomputers. With a bit of hand-typed code, copied from magazines or photocopies, we could see on screen, in ASCII or rudimentary pixels, colonies of nascent cells, dying, sometimes moving in stable structures (the “gliders”).

In 1981, at age 11 on my Sinclair ZX81 computer, I programmed a Game of Life myself. On the family television screen, I watched, fascinated, a population of pixels evolve: being born, reproducing, dying. This graphic organicity already seemed strangely familiar to me, like a miniature echo of living processes.

Here is the reproduction (in Javascript, whereas at the time I had programmed it in BASIC, the code is available at the end of the article) of the small program I had made at the time:

It works, you can play with it.

The same year, I discovered Benoît Mandelbrot’s fractals: infinitely complex forms, resembling the Breton coast or romanesco broccoli, arising from simple equations. Again, code generated structures that resembled nature. Mandelbrot said: “Clouds are not spheres, mountains are not cones... nature is fractal”. But at the time, I perceived these images as simulations, never as “real” life, obviously.

Mandelbrot set, programmed in 1984 on my MSX-standard Sega Yeno SC3000 computer and printed by myself with the Citizen 120D dot matrix printer.

The code of life: from DNA to GMOs

Then, as a teenager, I learned about the existence of DNA code: life itself is “programmed” by a sequence of chemical instructions. The organism obeys logic of dizzying complexity, which we will probably never finish deciphering.

This principle of biological coding became tangible with the rise of GMOs: inserting a new “program” into an organism to modify its resistance or productivity, for example. The operation, which seemed to belong to science fiction, has become established as now common agricultural practice, whose long-term effects on human health are, however, completely unknown.

In 2021, this logic directly affected billions of humans: messenger RNA “vaccines” introduced into our cells (well, not mine, I refused Covid vaccination) a temporary code designed to produce a protein and trigger an immune response. It was, fundamentally, a biological patch. But like any software, this code evolves in a complex environment and interacts with multiple systems. Classic protocols for vaccines require 5 to 10 years of study to evaluate these effects; during the Covid period, the experiment was global and in real time, which allowed unprecedented speed increases in major shareholders’ wealth: their fortunes doubled in two years!

When machines learn to feed and evolve

In July 2025, a team from Columbia University published a major breakthrough: robots equipped with artificial metabolism. Designed from magnetic hexagonal modules, they can contract, expand, assemble and... “feed” on other robots to recover their components.

These machines no longer just process information: they draw from their environment to grow and repair themselves. In experiments, they adapted their structure to overcome obstacles, like a robot-tetrahedron that spontaneously adds a module to use it as a cane. We are entering what these researchers call an “autonomous mechanical ecology.”

This transition from software to mechanical organic disrupts the paradigm of life: artificial intelligence had progressed, but robotic bodies remained frozen in their manufacturing. Now they combine software intelligence and physical plasticity, crossing a step toward “mechanical life.”

A convergence of metabolisms

Life, biological or mechanical, rests on the same necessity: transforming a resource into useful energy. For us, it’s food, converted into glucose that provides us with life energy; for machines, it’s electricity that brings them to life, sometimes produced from light or movement. In both cases, there is metabolization of matter to transform it into energy necessary for the functioning of the body, whether biological or mechanical.

Moreover, nothing prevents imagining a crossover: machines running on glucose, or human bodies assisted by internal electrical systems, like pacemakers. The principle is indeed identical: a metabolism transforming a resource to keep the system alive.

Thus, what I took for childish simulations on my ZX81 was perhaps already a form of life: not an imitation, but a reduced, coded manifestation of the universal process of life... and that’s why it was so fascinating.

Toward a philosophical redefinition of life

At the time, I separated simulation from real life. Today, therefore, I understand that these cellular automata were already an expression of life, in the sense that life is an organized, self-maintaining and evolutionary process, whether chemical, logical, mechanical, or all of these at once.

Yuval Noah Harari wrote in 2016 in Sapiens that soon, “life” would no longer be a purely biological concept. We are there: it becomes hybrid. Our machines acquire vital attributes (nutrition, reproduction, adaptation), and our bodies adopt logical and mechanical modifications. There is a real enrichment of the living, with capacities once reserved for machines, and machines adopting strategies once reserved for the living.

This shift is not just a question of technology: it engages reflection on our relationship to the living, on the very notion of “soul” and on possible cohabitation with non-biological but autonomous entities, just as we are.

The challenge is, in my view, to begin to seek to understand what these machines that are beginning to “come alive” change in our own definition of existence. As in the Game of Life, a few simple rules can produce unpredictable complexity, and, perhaps, a new form of humanity shared with our creations. When mechanical bodies and biological bodies share the same vital functions, are they still “different”? Perhaps, as Mandelbrot wrote, life is simply an “invariant pattern” deployed across various supports, carbon or silicon.

It is therefore not the entry into a virtual world that we are experiencing, but the enrichment of reality by new modalities of the living. The question is no longer whether machines can be alive, but how we, biological humans, will coexist with these new forms of life that we have engendered and which, perhaps, will survive us.

Appendix: Source code for The Game of Life

Code for The Game of Life in BASIC (language of the 1980s)

10 LET W=32 : LET H=22
20 DIM A(W,H)
30 REM INITIALISATION MANUELLE DES CELLULES
40 REM Exemple : activer quelques cellules
50 LET A(16,11)=1 : LET A(16,12)=1 : LET A(16,13)=1
60 LET A(15,12)=1 : LET A(17,12)=1
70 REM AFFICHER LA PREMIERE GENERATION
80 FOR X=1 TO W : FOR Y=1 TO H
90 IF A(X,Y)=1 THEN PLOT X,Y
100 NEXT Y : NEXT X
110 REM CALCUL DE LA GENERATION SUIVANTE
120 DIM B(W,H)
130 FOR X=2 TO W-1
140 FOR Y=2 TO H-1
150 LET N=0
160 FOR DX=-1 TO 1 : FOR DY=-1 TO 1
170 IF NOT (DX=0 AND DY=0) THEN LET N=N+A(X+DX,Y+DY)
180 NEXT DY : NEXT DX
190 IF A(X,Y)=1 THEN
200 IF N=2 OR N=3 THEN LET B(X,Y)=1 : ELSE LET B(X,Y)=0
210 ELSE
220 IF N=3 THEN LET B(X,Y)=1 : ELSE LET B(X,Y)=0
230 END IF
240 NEXT Y : NEXT X
250 REM EFFACER L’ANCIENNE GENERATION
260 FOR X=1 TO W : FOR Y=1 TO H
270 IF A(X,Y)=1 AND B(X,Y)=0 THEN UNPLOT X,Y
280 IF A(X,Y)=0 AND B(X,Y)=1 THEN PLOT X,Y
290 NEXT Y : NEXT X
300 REM COPIER B -> A POUR PROCHAINE GENERATION
310 FOR X=1 TO W : FOR Y=1 TO H : LET A(X,Y)=B(X,Y) : NEXT Y : NEXT X
320 REM BOUCLER
330 GOTO 130

Game of Life code in Python (modern language)

import random
import os
import time

def grille_aleatoire(taille, proba_vie):
    return [
        [1 if random.random() < proba_vie else 0 for _ in range(taille)]
        for _ in range(taille)
    ]

def afficher(grille):
    os.system('cls' if os.name == 'nt' else 'clear')
    for ligne in grille:
        print(''.join(['■' if cell else ' ' for cell in ligne]))

def prochain_etat(grille):
    taille = len(grille)
    nouvelle = [*taille for _ in range(taille)]
    for i in range(taille):
        for j in range(taille):
            voisins = 0
            for dx in [-1, 0, 1]:
                for dy in [-1, 0, 1]:
                    if dx == 0 and dy == 0:
                        continue
                    ni, nj = i+dx, j+dy
                    if 0 <= ni < taille and 0 <= nj < taille:
                        voisins += grille[ni][nj]
            if grille[i][j]:
                if voisins == 2 or voisins == 3:
                    nouvelle[i][j] = 1
            else:
                if voisins == 3:
                    nouvelle[i][j] = 1
    return nouvelle

# Paramètres
TAILLE = 20
PROBA_VIE = 0.2

grille = grille_aleatoire(TAILLE, PROBA_VIE)

while True:
    afficher(grille)
    grille = prochain_etat(grille)
    time.sleep(0.2)