ElectroTech · 11 November 2026

Bitluni et son GPU maison : 8 192 microcontrôleurs RISC-V à 13 centimes, en route vers 64 000 cœurs

En réaction à la flambée des prix des cartes graphiques, un ingénieur allemand a entrepris de construire son propre GPU en assemblant des milliers de microcontrôleurs RISC‑V. Le prototype actuel aligne 8 192 puces ; l’objectif final est de 64 000. Ce dossier décortique l’architecture, les performances théoriques, les défis thermiques et logiciels, et replace ce projet dans la mouvance du hardware ouvert. Que vaut vraiment cette approche face à un GPU NVIDIA ou AMD ?

Pourquoi un ingénieur a décidé de construire un GPU avec 64 000 microcontrôleurs à 13 centimes

L’inflation des prix des GPU grand public et professionnels, couplée aux pénuries de composants des dernières années, a poussé certains passionnés à explorer des voies alternatives. C’est dans ce contexte que Bitluni (Matthias Balwierz), figure bien connue de la scène hardware hacking, a entrepris un projet aussi audacieux que déroutant : fabriquer de toutes pièces un GPU à partir de microcontrôleurs RISC‑V ultra‑bon marché.

Bitluni n’est pas un inconnu dans le monde du maker computing. Ses précédentes réalisations – oscilloscopes DIY, synthétiseurs basés sur des microcontrôleurs, expériences avec des écrans LED – lui ont forgé une réputation de créateur ingénieux. Avec ce GPU maison, il pousse la logique à son paroxysme : plutôt que d’acheter une carte graphique à plusieurs milliers d’euros, il a décidé d’en assembler une à partir de composants vendus environ 13 cents pièce.

L’objectif affiché n’est pas de concurrencer directement une GeForce RTX 4090, mais de prouver qu’un système massivement parallèle, capable d’afficher des images, peut être construit avec des puces RISC‑V grand public. Le choix s’est porté sur le QingKe CH570, un microcontrôleur 32 bits cadencé à 100 MHz, embarquant USB, Bluetooth 5.0 LE et une interface 2,4 GHz. Son prix unitaire : environ 0,13 $ US. Pour 64 000 pièces, le coût des seules puces atteint 8 320 $ – une somme non négligeable, mais bien inférieure à celle d’un GPU professionnel haut de gamme.

Le prototype actuel fonctionne avec 8 192 puces. Bitluni a déjà présenté des démonstrations vidéo montrant l’affichage d’images simples sur une matrice de LEDs RGB, chaque puce pilotant directement une LED. La version finale visée, avec 64 000 cœurs, devrait offrir une résolution de 320×200 pixels – soit un retour aux standards des années 80, mais avec un nombre de processeurs digne d’un supercalculateur d’époque. Pour mémoire, une résolution Full HD aurait nécessité plus de deux millions de puces, un coût et une complexité rédhibitoires.

Le projet a été largement relayé par la presse spécialisée au cours de l’été 2026 : The Register a consacré un article au « madlad » qui construit un GPU maison avec 8 192 puces RISC‑V, tandis que TechSpot et TechEBlog ont détaillé l’approche matérielle. Le blog Circuit.rocks résume bien la prouesse : un « GPU 8 192 cœurs construit à partir de puces RISC‑V à 13 cents ». L’article publié par abpro-india.de confirme ces chiffres et précise l’équipement utilisé par le bricoleur : un CH570 Dev Kit pour le développement logiciel, une DP100 Mini PSU pour l’alimentation (soutenue par un chargeur USB‑C de 65 W et un câble de 100 W), une station de soudure Aifen A9ED et une myriade d’outils de précision. Le projet repose donc sur du matériel de prototypage accessible, renforçant son caractère maker.

Un réseau de 64 000 pixels pensé comme un supercalculateur des années 80

L’architecture de ce GPU DIY s’inspire ouvertement des premiers supercalculateurs vectoriels, en particulier le Cray‑1. Bitluni a opté pour un design circulaire : les cartes électroniques, disposées en arc de cercle, accueillent chacune un bloc de 16×32 pixels. Chaque pixel est une LED RGB soudée directement sur le microcontrôleur CH570 qui la pilote. Ce choix de LED basiques, plutôt que des LED adressables plus évoluées, a été dicté par le budget : des LED adressables auraient fait exploser le coût du projet.

L’organisation est hiérarchique. Les 64 000 puces sont réparties en groupes de 32, chaque groupe étant supervisé par un contrôleur CH32V (un autre microcontrôleur RISC‑V). Ce contrôleur assure la coordination locale : il reçoit les instructions de rendu, les traduit en commandes pour chaque CH570, et gère la synchronisation intra‑groupe. L’ensemble des contrôleurs CH32V est lui‑même connecté à une unité centrale – probablement un PC hôte ou un FPGA – qui envoie les trames d’affichage.

L’absence de mémoire partagée globale est une contrainte majeure. Chaque CH570 dispose de sa propre RAM interne, mais il n’existe pas de VRAM centralisée comme sur un GPU classique. Les données d’affichage doivent être distribuées par les contrôleurs CH32V, ce qui impose une topologie de réseau en étoile à plusieurs niveaux. La synchronisation inter‑puces repose sur des signaux d’horloge et des lignes de contrôle dédiées, probablement via les interfaces GPIO et SPI des microcontrôleurs.

Cette architecture rappelle les massively parallel processor arrays des années 80 (Connection Machine, ILLIAC), mais avec des composants modernes et un coût dérisoire. Le défi principal est la latence de communication : chaque groupe de 32 puces doit recevoir ses instructions en temps réel pour éviter un décalage visible à l’écran. Bitluni n’a pas divulgué les détails de son protocole de synchronisation, mais on peut supposer qu’il utilise une trame d’horloge commune et des buffers locaux.

L’article d’abpro-india.de insiste sur l’aspect distribué : « Chaque microcontrôleur ne travaille pas de manière isolée. Au contraire, ils collaborent, se répartissant les tâches de calcul et synchronisant les données pour construire l’image finale. » Une description qui évoque une « gigantesque ruche d’électronique », où chaque abeille contribue à la fresque visuelle. Le site souligne également l’intégration GPU/écran : chaque puce pilote directement son LED RGB, éliminant le besoin d’un signal vidéo externe. Une approche qui constitue « une véritable fenêtre ouverte sur le cœur même du rendu graphique ».

Aucun benchmark, mais des promesses : que peut vraiment faire ce GPU ?

C’est le point le plus délicat de ce dossier : aucune mesure de performance chiffrée n’est disponible dans les sources consultées. Pas de GFLOPS FP32 ou FP64, pas de bande passante mémoire, pas de latence de rendu. Le projet en est encore au stade de prototype fonctionnel, capable d’afficher des images statiques et probablement des animations simples. Bitluni n’a pas communiqué de résultats de benchmarks, ni comparé son système à un GPU NVIDIA ou AMD.

On peut néanmoins établir quelques ordres de grandeur théoriques.

• Fréquence : 100 MHz par cœur. En comparaison, un GPU moderne tourne entre 1,5 et 2,5 GHz. Même avec 64 000 cœurs, la fréquence ridiculement basse limite le débit d’instructions.
• Parallélisme massif : 64 000 cœurs, c’est bien plus que les 10 496 cœurs CUDA d’une RTX 3090. Mais chaque cœur CH570 est un microcontrôleur 32 bits sans unité de calcul flottant dédiée (ou très rudimentaire). Les capacités de calcul vectoriel sont quasi nulles.
• Résolution : 320×200 pixels, soit 64 000 pixels. Chaque pixel est géré par un cœur indépendant. C’est l’équivalent d’un écran VGA basse résolution. Aucune possibilité de rendu 3D texturé, de shaders ou d’effets modernes.
• Mémoire : chaque puce dispose de quelques kilo-octets de RAM interne. Pas de VRAM partagée, pas de cache cohérent. Impossible de charger des textures ou des buffers de géométrie complexes.

En l’état, ce GPU DIY ne peut pas exécuter un jeu moderne, ni même un benchmark comme 3DMark. Il est conçu pour de l’affichage pixel‑par‑pixel, du calcul parallèle simple (par exemple, simulation de particules, affichage de fractales, ou rendu de motifs géométriques basiques). Les charges de travail testées par Bitluni ne sont pas documentées ; on ignore s’il a tenté du calcul scientifique (addition matricielle, FFT) ou du minage de cryptomonnaies.

Le projet reste donc une preuve de concept – impressionnante par son échelle, mais très loin des capacités d’un GPU commercial même d’entrée de gamme. Une GTX 1060, sortie en 2016, offre 1 280 cœurs CUDA à 1,5 GHz, 6 Go de VRAM, et une résolution 1080p en 3D. Le GPU de Bitluni ne peut rivaliser sur aucun de ces points.

2 161 watts pour 320×200 pixels : le cauchemar du refroidissement

La consommation électrique annoncée est l’un des chiffres les plus frappants du projet. Selon TechSpot, le prototype actuel consommerait 2 161 watts, soit 655 ampères sous 3,3 V. Ce chiffre est ambigu : pourrait‑il correspondre à la version 64 000 puces plutôt qu’au prototype 8 192 ? Un calcul simple donne une piste.

Chaque CH570 consomme individuellement environ 10 mA sous 3,3 V, soit 0,033 W. Pour 8 192 puces, on obtiendrait 270 W ; pour 64 000, 2 112 W. Les 2 161 W annoncés sont très proches de cette dernière estimation, ce qui laisse penser que le chiffre concerne la configuration finale. Mais l’article de TechSpot le présente dans le contexte du « current setup » après avoir décrit le prototype à 8 192 puces. L’ambiguïté n’est pas levée.

Quoi qu’il en soit, dissiper plus de 2 kW dans un espace restreint est un défi thermique colossal. Bitluni avait envisagé un refroidissement par immersion liquide, mais l’a abandonné pour des raisons de coût et d’impact environnemental. Aucun système de refroidissement actif (ventilateurs, radiateurs, waterblock) n’est décrit dans les sources. On ignore comment le prototype actuel évacue la chaleur – peut‑être par convection naturelle, étant donné la faible densité thermique par cœur (≈0,034 W/puce, soit 34 mW). Mais à l’échelle de 64 000 puces, la surface totale est grande, et la chaleur doit être extraite efficacement.

La densité thermique surfacique n’est pas calculable sans connaître la taille des cartes. On peut supposer que chaque carte de 16×32 pixels (512 puces) dissipe environ 17 W (512 × 0,033 W), ce qui est gérable avec un petit dissipateur. Le problème est l’alimentation : fournir 655 A sous 3,3 V nécessite des convertisseurs DC‑DC puissants et un câblage en cuivre épais. Bitluni utilise une alimentation Corsair WS3000 ATX (probablement une unité de 3 000 W) et des convertisseurs 12 V → 3,3 V. L’article d’abpro-india.de mentionne également une DP100 Mini PSU comme source d’alimentation de test, soutenue par un chargeur USB‑C de 65 W – une solution de banc, loin des besoins de la version finale.

Aucune mesure de température (en charge ou au repos) n’est rapportée. Le refroidissement reste l’un des aspects les plus flous du projet.

Flasher 64 000 puces avec une imprimante 3D : l’ingénierie logicielle au défi

Programmer 64 000 microcontrôleurs individuels est un cauchemar logistique. Bitluni a mis au point un outil de programmation à trois broches monté sur une imprimante 3D. Le principe : l’imprimante déplace une tête de flashage au‑dessus de chaque puce, établit un contact électrique via des pointes, et téléverse le firmware. Ce système permet de flasher les puces en lot, mais le temps nécessaire pour 64 000 unités reste considérable.

L’article d’abpro-india.de apporte un éclairage supplémentaire : Bitluni a développé Pixel Pump, un logiciel dédié à la génération et à la distribution des données d’affichage vers les puces. Ce nom fait écho à un autre outil du même auteur, un système de pick‑and‑place open source également baptisé Pixel Pump, mais les deux projets sont distincts. Dans le cadre du GPU, Pixel Pump joue le rôle de « compilateur graphique » : il transforme une image ou une scène en un flux de commandes adressées à chaque CH570, en tenant compte de la topologie en groupes de 32 et de la hiérarchie des contrôleurs CH32V.

Cette couche logicielle est sans doute l’un des apports les plus intéressants du projet. Elle illustre un problème classique du calcul distribué : comment décomposer une tâche globale (afficher une image) en sous‑tâches indépendantes, puis recombiner les résultats sans conflit. Sur un GPU classique, cette décomposition est prise en charge par le matériel (warps, blocs, mémoire partagée). Ici, tout repose sur du code et sur un réseau de communication artisanal.

Le firmware embarqué sur chaque CH570 doit être minimal : recevoir une valeur de couleur, piloter la LED RGB correspondante, et éventuellement participer à des calculs simples. La contrainte de mémoire (quelques kilo‑octets) interdit toute pile logicielle lourde. Bitluni a donc dû écrire un firmware en C très compact, probablement sans système d’exploitation.

Le défi du débogage est également considérable. Sur 8 192 puces, une seule puce mal flashée ou un fil mal soudé peut produire un pixel mort ou une ligne défaillante. Bitluni a documenté dans ses vidéos des séances de diagnostic fastidieuses, où il faut localiser la puce fautive parmi des milliers. À l’échelle de 64 000, la maintenance devient un problème industriel.

Ce que ce projet dit du hardware ouvert et du RISC‑V en 2026

Au‑delà de l’anecdote, le GPU de Bitluni s’inscrit dans une tendance de fond : la démocratisation du RISC‑V et du hardware ouvert. Le CH570, microcontrôleur RISC‑V à 13 cents, illustre la pression tarifaire qui s’exerce sur les composants d’entrée de gamme. En 2026, le RISC‑V n’est plus un objet de laboratoire : il équipe des cartes de développement grand public, des capteurs, des contrôleurs embarqués. Notre dossier sur les cartes de développement 2026 a montré comment le RISC‑V est devenu une option par défaut sous les 20 €, aux côtés de l’ESP32 et du RP2350.

Le projet de Bitluni pousse cette logique à l’extrême : utiliser des puces à quelques centimes pour construire un système massivement parallèle. Il ne s’agit pas d’un produit, mais d’une démonstration de faisabilité. Et c’est précisément là son intérêt : il rappelle que l’innovation en électronique ne vient pas seulement des grands fondeurs, mais aussi de la communauté maker, qui explore des architectures improbables avec des moyens limités.

Le parallèle avec les supercalculateurs des années 80 est frappant. Le Cray‑1, lancé en 1976, alignait quelques millions de transistors et coûtait plusieurs millions de dollars. Le GPU de Bitluni aligne 64 000 processeurs pour un coût de l’ordre de 10 000 $, avec une puissance de calcul incomparablement plus faible, mais une philosophie similaire : le parallélisme massif comme réponse aux limites du calcul séquentiel.

Le projet soulève aussi des questions sur la soutenabilité. Consommer 2 kW pour afficher 320×200 pixels est un non‑sens énergétique. Mais c’est justement ce contraste qui rend la démonstration pédagogique : il montre à quel point les GPU modernes sont efficaces, capables de rendu 4K en temps réel pour quelques centaines de watts. La comparaison, loin de discréditer Bitluni, met en valeur le génie des architectures intégrées.

Enfin, le projet illustre la vitalité de la scène hardware hacking en 2026. Des créateurs comme Bitluni, mais aussi des communautés autour de l’open hardware, repoussent les limites de ce qui est réalisable avec des composants bon marché. Leurs travaux alimentent parfois l’industrie : les outils de prototypage rapide, les formats de cartes ouverts, les firmwares alternatifs finissent par influencer les produits commerciaux.

Faut‑il s’attendre à un GPU DIY dans nos PC ?

Non. Le GPU de Bitluni ne remplacera jamais une carte graphique commerciale. Il ne peut pas exécuter de jeux modernes, ne supporte pas les API graphiques (Vulkan, DirectX, OpenGL), et sa consommation électrique est absurde. Son intérêt est ailleurs : il s’agit d’une œuvre d’ingénierie, d’une exploration des limites du possible avec des moyens dérisoires.

En revanche, le projet a une valeur éducative indéniable. Il montre comment fonctionne un système massivement parallèle, comment on décompose une image en pixels, comment on synchronise des milliers de processeurs. Pour un étudiant en architecture des ordinateurs, c’est une leçon concrète plus parlante que bien des cours théoriques.

Il pose aussi une question de fond : jusqu’où peut‑on descendre en coût tout en conservant une capacité de calcul utile ? Les microcontrôleurs RISC‑V à 13 cents ouvrent des perspectives pour des applications où le prix est le facteur limitant : capteurs distribués, affichages géants, systèmes de calcul redondants. Le GPU de Bitluni est une vitrine de ces possibilités.

Reste à voir si le projet atteindra son objectif de 64 000 puces. Bitluni a déjà démontré la faisabilité avec 8 192. Le passage à l’échelle supérieure posera des défis de câblage, d’alimentation et de refroidissement qui pourraient ralentir le projet. Mais l’ingénieur a prouvé qu’il savait résoudre des problèmes complexes avec des moyens limités. La suite promet d’être passionnante.

Sources

• TechSpot — Hardware hacker is building a homemade GPU from 64,000 tiny RISC-V chips
• The Register — Madlad builds homebrew GPU using 8,192 RISC-V chips
• TechEBlog — Bitluni Built a GPU From 8,192 Tiny Processors
• Circuit.rocks — Bitluni’s 8,192-Core DIY GPU Is Built From 13-Cent RISC-V Chips
• abpro-india.de — Bitluni défie les géants : un GPU DIY à base de microcontrôleurs

Article recherché et rédigé automatiquement · Magazine Electrosens