Les machines déjà organiques

Nous assistons à l’émergence de formes de vie qui transcendent le biologique. Ce que nous pensions n’être que simulations devient réalité : les machines commencent à acquérir métabolisme et autonomie.

Des pixels vivants : mes premiers automates organiques

En 1970, John Conway invente un petit programme informatique, le Jeu de la vie, un « automate cellulaire » dont les règles sont très simples : une cellule vivante survit avec deux ou trois voisines ; une cellule morte renaît avec exactement trois voisines ; toutes les autres meurent ou restent mortes.

Au début des années 1980, le Jeu de la vie était un programmes qui se répandait sur les micro-ordinateurs personnels. Avec un peu de code tapé à la main, recopié dans des journaux ou sur des photocopies, on voyait sur l’écran, en ASCII ou en pixels rudimentaires, des colonies de cellules naissantes, mourantes, se déplaçant parfois en structures stables (les « planeurs »).

En 1981, à 11 ans sur mon ordinateur Sinclair ZX81, je programmais moi-même un Jeu de la vie. Sur l’écran du téléviseur familial, je regardais, fasciné, une population de pixels évoluer : naître, se reproduire, mourir. Cette organicité graphique me semblait déjà étrangement familière, comme un écho miniature aux processus du vivant.

Voici la reproduction (en Javascript, alors qu’à l’époque je l’avais programmé·e en BASIC, le code est disponible à la fin de l’article) du petit programme que j’avais fait à l’époque :

Il fonctionne, vous pouvez jouer avec.

La même année, je découvrais les fractales de Benoît Mandelbrot : des formes infiniment complexes, ressemblant à la côte bretonne ou au chou romanesco, issues d’équations simples. Là encore, le code engendrait des structures qui ressemblaient à la nature. Mandelbrot disait : « Les nuages ne sont pas des sphères, les montagnes ne sont pas des cônes… la nature est fractale ». Mais à l’époque, je percevais ces images comme des simulations, jamais comme de la « vraie » vie, évidemment.

Ensemble de Mandelbrot, programmé en 1984 sur mon ordinateur Sega Yeno SC3000 (norme MSX) et imprimé par mes soins avec l’imprimante à aiguilles Citizen 120D.

Le code de la vie : de l’ADN aux OGM

Puis, adolescent, j’apprenais l’existence du code ADN : la vie elle-même est « programmée » par une suite d’instructions chimiques. L’organisme obéit à une logique d’une complexité vertigineuse, que nous n’aurons sans doute jamais fini de déchiffrer.

Ce principe de codage biologique est devenu tangible avec l’essor des OGM : insérer un nouveau « programme » dans un organisme pour modifier sa résistance ou sa productivité, par exemple. L’opération, qui semblait relever de la science-fiction, s’est imposée comme pratique agricole désormais courante, dont par contre les effets à long terme sur la santé humaine sont tout à fait inconnus.

En 2021, cette logique a touché directement des milliards d’humain·e·s : les « vaccins » à ARN messager ont introduit dans nos cellules (enfin, pas les miennes, j’ai refusé la vaccination Covid) un code temporaire destiné à produire une protéine et déclencher une réponse immunitaire. C’était, au fond, un patch biologique. Mais comme tout logiciel, ce code évolue dans un environnement complexe et interagit avec des systèmes multiples. Les protocoles classiques pour les vaccins exigent 5 à 10 ans d’étude pour évaluer ces effets ; pendant la période Covid, l’expérience a été mondiale et en temps réel, ce qui a permis des augmentations de richesses des grand·e·s actionnaires à une vitesse sans précédent : leurs fortunes ont doublé en deux ans !

Quand les machines apprennent à se nourrir et à évoluer

En juillet 2025, une équipe de l’Université de Columbia a publié une avancée majeure : des robots dotés d’un métabolisme artificiel. Conçus à partir de modules hexagonaux magnétiques, ils peuvent se contracter, se dilater, s’assembler et… se « nourrir » d’autres robots pour récupérer leurs composants.

Ces machines ne se contentent plus de traiter l’information : elles puisent dans leur environnement pour croître et se réparer. Lors d’expériences, elles ont adapté leur structure pour franchir des obstacles, comme un robot-tétraèdre qui ajoute spontanément un module pour s’en servir de canne. Nous entrons ici dans ce que ces chercheur·euse·s appellent une « écologie mécanique autonome ».

Ce passage du logiciel à l’organique mécanique bouleverse le paradigme de la vie : l’intelligence artificielle avait progressé, mais les corps robotiques restaient figés dans leur fabrication. Désormais, ils combinent intelligence logicielle et plasticité physique, franchissant une étape vers une « vie mécanique ».

Une convergence des métabolismes

La vie, biologique ou mécanique, repose sur la même nécessité : transformer une ressource en énergie utile. Pour nous, ce sont les aliments, convertis en glucose qui nous fournit l’énergie de vie ; pour les machines, c’est l’électricité qui les met en vie, parfois produite à partir de lumière ou de mouvement. Dans les deux cas, il y a métabolisation d’une matière pour la transformer en énergie nécessaire au fonctionnement du corps, qu’il soit biologique ou mécanique.

D’ailleurs, rien n’interdit d’imaginer un croisement : des machines fonctionnant au glucose, ou des corps humains assistés par des systèmes électriques internes, comme les pacemakers. Le principe est bien identique : un métabolisme transformant une ressource pour maintenir le système en vie.

Ainsi, ce que je prenais pour des simulations enfantines sur mon ZX81 était peut-être déjà une forme de vie : non pas une imitation, mais une manifestation réduite, codée, du processus universel de la vie... et c’est pourquoi c’était si fascinant.

Vers une redéfinition philosophique de la vie

À l’époque, je séparais la simulation de la vie réelle. Aujourd’hui, donc, je comprends que ces automates cellulaires étaient déjà une expression de la vie, au sens où la vie est un processus organisé, auto-entretenu et évolutif, qu’il soit chimique, logique, mécanique, ou tout cela à la fois.

Yuval Noah Harari écrivait en 2016 dans Sapiens que, bientôt, la « vie » ne serait plus un concept purement biologique. Nous y sommes : elle devient hybride. Nos machines acquièrent des attributs vitaux (nutrition, reproduction, adaptation), et nos corps adoptent des modifications logiques et mécaniques. Il y a un enrichissement réel du vivant, avec des capacités jadis réservées aux machines, et des machines adoptant des stratégies jadis réservées au vivant.

Ce basculement n’est pas qu’une question de technologie : il engage une réflexion sur notre rapport au vivant, sur la notion même d’« âme » et sur la cohabitation possible avec des entités non biologiques mais autonomes, tou·te·s comme nous le sommes.

L’enjeu est à mon sens de commencer à chercher à comprendre ce que ces machines qui commencent à « prendre vie » changent à notre propre définition de l’existence. Comme dans le Jeu de la vie, quelques règles simples peuvent produire une complexité imprévisible, et, peut-être, une nouvelle forme d’humanité partagée avec nos créations. Lorsque les corps mécaniques et les corps biologiques partagent les mêmes fonctions vitales, sont-ils encore « différents » ? Peut-être, comme l’écrivait Mandelbrot, la vie est-elle simplement un « motif invariant » déployé à travers divers supports, carbone ou silicium.

Ce n’est pas donc l’entrée dans un monde virtuel que nous vivons, mais l’enrichissement du réel par de nouvelles modalités du vivant. La question n’est plus de savoir si les machines peuvent être vivantes, mais comment nous, humain·e·s biologiques, allons coexister avec ces nouvelles formes de vie que nous avons engendrées et qui, peut-être, nous survivront.

Annexe : Code source du Jeu de la vie

Code du Jeu de la vie en BASIC (langage des années 80)

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

Code du Jeu de la vie en Python (langage moderne)

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)

[x]) ctx.fillRect(x*s,y*s,s,s) ;
}
setInterval(step,80) ;