Eight thousand status LEDs blink at once across a rack of plug-in blades, each one a separate RISC-V chip chewing on its slice of the work. Bitluni’s newest build is a graphics processor stitched together from 8,192 microcontrollers that cost roughly $0.13 each. It started, as these things do, with a bulk order he could not resist.
What he built
A GPU is really just a processor carrying a very large number of simple cores. Bitluni already had a very large number of simple cores on the shelf from earlier cluster experiments, so he wired 8,192 WCH CH570 chips into one parallel array. Each CH570 clocks up to 100 MHz and holds 12 KB of SRAM, which is nothing on its own. Groups of 32 report to a bigger CH32V microcontroller that hands work down and gathers results back, so the host never has to talk to thousands of chips directly.
How he pulled it off
Signal routing at this scale needed six-layer PCBs with shielded traces to keep cross-talk out. The first clock scheme failed outright: one oscillator driving dozens of chips sagged under the electrical load, so every microcontroller ended up with its own crystal. The board files then choked the PCB house’s software, which pushed the design into modular blades that seat onto a backplane through PCIe edge connectors. Flashing firmware pad by pad was never going to happen by hand, so Bitluni bolted a pogo-pin fixture to a printer toolhead and let a Python script walk it from chip to chip. Power turned into its own build: a 3 kW supply feeds Murata buck converters that shove more than 650 A onto a single 3.3 V rail, cooled for now by loud fans instead of the immersion loop he originally sketched.
The takeaway
Call it a GPU or call it a very stubborn microcontroller cluster; the interesting part is where it broke. Clock distribution is the gotcha nobody warns you about in a datasheet, and it bites at a dozen chips long before it bites at eight thousand. Cross-talk, fan-out limits, and current density are the same problems whether you are laying out one blade or one breadboard. Start small: hang two RP2040 or ESP32 boards off a shared I2C bus, watch what happens to SDA and SCL when you drop the pull-ups from 4.7k to 10k, then scale to four. That failure mode is the same one that forced 8,192 crystals onto Bitluni’s boards. Full build writeup and video: Hackster.io.
Frequently Asked Questions
What microcontroller does this DIY GPU use?
It runs on 8,192 WCH CH570 chips, a RISC-V microcontroller that clocks up to 100 MHz with 12 KB of SRAM and sells for around $0.13. Every group of 32 is supervised by a larger CH32V microcontroller that distributes work and collects results.
Why does each chip need its own crystal oscillator?
The first design tried to fan one clock signal out to dozens of chips. The combined electrical load dragged the signal down until nothing ran reliably, so the boards were redesigned to give every microcontroller a dedicated crystal. Clock distribution is a real constraint once you pass a handful of loads.
What will I learn if I build something like this?
Even a four-chip version teaches parallel task splitting, multi-master bus behavior, clock fan-out limits, and power budgeting. You practice reading a datasheet for current draw, calculating pull-up values for I2C, and writing firmware that coordinates rather than computes alone. Those are the same skills a thesis-level embedded project needs, minus the 650-amp rail.
