A YouTuber and electronics enthusiast has built a working graphics processing system from scratch using over 8,000 individual microcontroller chips, demonstrating that custom hardware design and open-source approaches can rival traditional GPU architectures. Bitluni's ultra cluster, which took years of iterative development, packs 8,192 individual microcontrollers running at 100 megahertz and managed by 256 larger controller chips, all working in concert to render graphics and light patterns.

This project represents a significant departure from the dominant GPU market, where companies like NVIDIA control the landscape with proprietary architectures such as Blackwell. Instead of purchasing expensive graphics cards, Bitluni chose to build from the ground up using commodity parts, specifically the CH570 microcontroller, which costs roughly 13 cents in bulk. Each chip handles a single pixel location on a display, allowing the distributed system to function as a makeshift graphics processor without relying on centralized processing.

What Engineering Challenges Did Scaling to 8,000 Chips Create?

Building a system of this magnitude revealed problems that smaller DIY projects never encounter. The initial design used a shared clock signal, but this approach failed when thousands of chips were added to the board, becoming overwhelmed and ceasing to operate. To solve this, Bitluni switched to giving each microcontroller its own crystal oscillator, eliminating the single point of failure.

Signal integrity became another critical issue. Packing thousands of chips onto a single board created crosstalk, where electrical signals from one trace bled into adjacent traces and corrupted data. The solution involved upgrading to six-layer circuit boards with ground planes on the inner layers and staggering the traces so signals from adjacent levels did not interfere with each other. Power delivery and thermal management transformed into complete engineering projects on their own. With so many tiny chips running at 3.3 volts and drawing hundreds of amps collectively, the system requires a 3-kilowatt power supply and efficient voltage converters to keep everything operating smoothly.

How Did Bitluni Program and Manufacture Such a Complex System?

Programming 8,192 individual chips by hand would have taken weeks and been impractical. Instead, Bitluni took an unconventional approach: he modified a 3D printer by installing pogo pins on the gantry arm and writing Python scripts that move the print head across each board, automatically flashing firmware through exposed contact pads. This automation allowed him to program thousands of chips in a fraction of the time manual methods would require.

The physical design also required creative problem-solving. A single large board proved too large to manufacture using standard processes, so Bitluni divided the system into modular blades. Each blade is a grid of microcontrollers and small RGB light-emitting diodes (LEDs) that slide into a central circular backplane with edge connectors, giving the finished product the appearance of modern art rather than traditional computer hardware.

Steps to Understanding Distributed GPU Architecture

• Distributed Processing Model: Instead of one powerful processor handling all graphics calculations, each microcontroller manages a single pixel location independently, then coordinates with neighboring chips through communication buses.
• Communication Infrastructure: The system uses Serial Peripheral Interface (SPI) buses, with each set of 32 worker chips sharing one bus and larger controllers handling overall coordination, limiting bandwidth but enabling modular scaling.
• Power and Cooling Strategy: The system currently uses powerful fans rather than the planned immersion cooling tank, with a 3-kilowatt power supply and efficient buck converters distributing power across hundreds of amps of demand.
• Real-World Performance Limitations: The bandwidth constraints mean this system cannot push high-resolution frames as quickly as dedicated GPUs like NVIDIA's Blackwell architecture, but that was never the project's goal.

Currently, the system is running well enough to display synchronized light patterns across over 1,000 processors, each driving its own 1-millimeter by 1-millimeter RGB LED. The blades light up in succession or in waves, creating visually impressive demonstrations. Bitluni has even begun experimenting with distributed ray marching, a rendering technique used in some real-time graphics demos, and plans to conduct more rigorous testing once additional blades come online.

The broader significance of this project lies not in competing directly with NVIDIA or other commercial GPU manufacturers, but in demonstrating how far open-source hardware design and low-cost components can be pushed. Once the project advances to its next phase, Bitluni plans to make the files and code publicly available, allowing other makers and engineers to build upon his work and explore alternative approaches to graphics processing. This open-source philosophy contrasts sharply with the proprietary nature of commercial GPU architectures and could inspire a new generation of custom hardware projects.