Somewhere between “I like tabletop games” and “I own tweezers that cost more than my first keyboard,” there is a magical project called the glowing LED D20. It looks like a futuristic artifact a wizard would pull from a velvet pouch, except this one is not powered by ancient runes. It is powered by careful PCB design, tiny RGB LEDs, firmware, an FPGA, and the kind of patience usually reserved for restoring old watches or teaching a cat to respect furniture.
The project, created by maker Greg Davill, turns the classic twenty-sided die into a compact glowing icosahedron packed with 2,400 RGB LEDs. That means each of its 20 triangular faces carries 120 tiny lights. In other words, this is not just a dice-inspired lamp. It is a miniature display system wearing a dungeon-crawler costume.
Even better, the hardware design files are publicly available, which means ambitious makers can study the build, modify it, and attempt their own version. Notice the word “ambitious.” This is not a weekend craft where you hot-glue fairy lights to a plastic die and call it “cyberpunk.” This is a serious electronics project involving custom boards, surface-mount assembly, ribbon cables, 3D-printed mechanical parts, and a controller architecture designed to make thousands of tiny LEDs behave like obedient pixels instead of a chaotic rave in a shoebox.
What Is the Glowing LED D20?
A D20 is the famous twenty-sided die used in tabletop role-playing games, especially fantasy systems where one roll can decide whether your hero lands a critical hit or dramatically trips over a suspiciously ordinary chair. Geometrically, it is a regular icosahedron: 20 triangular faces, 30 edges, and 12 vertices. As an electronics platform, that shape is both beautiful and annoying. Beautiful because it distributes surfaces in every direction. Annoying because flat circuit boards generally prefer to stay flat, while an icosahedron insists on being a tiny architectural problem.
Davill’s LED D20 solves that challenge with 20 triangular LED panels joined into a 3D shell. The project uses 2,400 small 1.5 mm by 1.5 mm RGB LEDs, split evenly across the 20 sides. Unlike many maker lighting projects that rely on addressable LED packages such as WS2812-style pixels, this design uses more traditional RGB LEDs controlled directly by the project’s hardware. That decision makes the engineering more complex, but it also allows a remarkably dense display surface.
The result is a glowing polyhedral object that can display animations, color patterns, gradients, and mesmerizing effects across a faceted body. It is part sculpture, part dice tribute, part tiny video wall, and part “please do not drop this on game night.”
Why 2,400 LEDs Is a Big Deal
It is easy to say “2,400 LEDs” and move on, but the number deserves a dramatic pause. Many hobby LED projects use a strip of 30, 60, or 144 LEDs. A typical small matrix might use 64 or 256 pixels. This D20 contains 2,400 RGB LEDs, and each RGB LED contains red, green, and blue elements. That means the project is managing thousands of light-emitting channels inside a compact, angled object.
With 120 LEDs per face, the D20 can create effects that feel much smoother than a simple decorative light. A rainbow can roll across the object. A pulse can travel from one point to another. A face can glow like a magical glyph. With the right firmware, the entire object can behave like a low-resolution 3D display.
The density matters because this is not a giant prop. Commercial RGB matrix panels are usually rectangular and often designed for signs, walls, or displays. Shrinking that idea into a handheld icosahedron requires custom triangular boards and tight spacing. The project is impressive because it does not merely attach LEDs to a D20 shape; it integrates the geometry and electronics into the same design language.
The Hardware Behind the Magic
At the center of the LED D20 is a custom controller board connected to 20 triangular LED panel boards. The open hardware files list a controller PCBA, 20 triangular PCBAs, flat-flex cables, 3D-printable enclosure pieces, and a Sony NP-FW50-style camera battery. The triangular panels form the visible shell, while the controller and battery sit inside the compact frame.
Triangular LED Panels
The triangular panels are the real stars. Each one has to carry a dense arrangement of LEDs while still fitting into the physical geometry of an icosahedron. That means routing, component placement, power distribution, and connector positioning all matter. A tiny mistake on one panel is annoying. A tiny mistake repeated across 20 panels is how electronics teaches humility.
In fact, Davill documented a hardware revision issue involving swapped transistor pads, which required extensive rework on early boards. The public repository recommends using the newer r0.3 version of the triangular boards because earlier versions had serious errata. For builders, this is an important lesson: open-source hardware is powerful, but you still need to read the notes before ordering boards. Skipping that step is how your project becomes a very expensive coaster collection.
SAMD51 Microcontroller
The project uses a SAMD51-class microcontroller, a powerful Arm Cortex-M4F-based chip family commonly used in advanced embedded projects. In a build like this, the microcontroller can handle higher-level tasks: animations, frame preparation, input handling, communication, and coordination. It is the project’s stage manager, making sure the light show knows what scene comes next.
iCE40UP5K FPGA
The LED-driving workload is supported by a Lattice iCE40UP5K FPGA. An FPGA is not programmed like a normal microcontroller. Instead, it is configured into digital hardware logic. That makes it useful for timing-sensitive, parallel tasks, especially when many outputs need to update quickly and predictably.
In simple terms, the microcontroller can decide what the D20 should display, while the FPGA helps push that display data out to the LED panels efficiently. This division of labor is one reason the project feels more like a miniature product prototype than a casual blink-an-LED experiment.
Why Not Just Use NeoPixels?
Addressable LEDs are wonderful. They simplify wiring, let a microcontroller control long chains of pixels, and make colorful projects approachable for beginners. Many makers build excellent wearables, signs, lamps, and props with them. So why would anyone choose the harder path?
The answer is density and control. Addressable LEDs include driver electronics inside each package, which is convenient but adds size, cost, timing constraints, and layout limitations. Davill’s D20 uses small, old-school RGB LEDs and external driving hardware. That makes the control system more complicated, but it helps achieve a tightly packed display on small triangular panels.
Think of it like cooking. Addressable LEDs are the pre-chopped vegetable mix: convenient, fast, and excellent for many meals. This D20 is the chef who insists on dicing every ingredient by hand because the final plating demands it. Is it harder? Absolutely. Does it look spectacular? Also absolutely.
Build Difficulty: Not Beginner, Not Impossible
Let’s be honest: this is not a first soldering project. If your most recent electronics achievement was successfully plugging in a USB cable on the second try, the LED D20 may be a bit aggressive. The build involves fine surface-mount parts, custom PCBs, tiny LEDs, careful inspection, and a tolerance for debugging problems that may be invisible without magnification.
However, “difficult” does not mean “impossible.” It means you should approach the project like a serious maker build. Read the documentation. Review the bill of materials. Check the board revision. Practice surface-mount soldering on simpler boards. Make sure you understand power requirements. Use proper tools, including tweezers, magnification, flux, solder paste, and hot-air or reflow equipment when appropriate.
Builders should also respect battery safety. A camera-style lithium-ion battery can provide the power needed for a compact portable device, but lithium-ion cells must be charged, protected, mounted, and handled correctly. A glowing D20 is cool. A glowing workbench for the wrong reason is not cool.
What Makes This Project So Appealing?
The glowing LED D20 works because it combines several communities at once. Tabletop gamers immediately recognize the shape. Electronics enthusiasts appreciate the custom display engineering. 3D-printing fans notice the mechanical frame. Firmware developers see a playground for animations. Open-source hardware supporters appreciate that the design files can be studied and improved.
It also has personality. A cube-shaped LED matrix is impressive, but a D20 has narrative energy. It suggests chance, adventure, storytelling, and nerdy drama. When it glows, it feels like a prop from a fantasy tavern built by someone who also owns an oscilloscope.
This is exactly the kind of object that makes people lean closer and ask questions. Is it a die? Is it a lamp? Is it a display? Can it roll? Should it roll? Will the dungeon master allow it? The best answer is probably: it is a beautiful electronics sculpture inspired by a die, and you should not throw it unless you enjoy emotional damage and replacement PCBs.
Ideas for Customizing Your Own LED D20
Once the hardware exists, the creative possibilities multiply. A builder could program dice-roll animations where numbers flash and settle dramatically. The D20 could glow red on a critical failure and explode into gold on a natural 20. It could display idle animations during game night, serve as a desk lamp, or become an interactive prop for streaming tabletop sessions.
More advanced makers might add wireless control, sound reactivity, accelerometer-based motion effects, or USB animation uploads. A gentle breathing animation could make it look enchanted. A spinning rainbow could turn it into a desktop disco artifact. A “boss battle mode” could pulse ominously whenever the party makes a terrible decision, which, statistically, is every 12 minutes.
There is also room for mechanical experimentation. Diffusion layers could soften the LED points. Frosted 3D-printed panels might create a gem-like glow. A display stand could include charging contacts. A protective outer shell could make the object more practical for handling. The original design already demonstrates what is possible; the community can take the concept in many directions.
Lessons Makers Can Learn from the LED D20
1. Shape Changes Everything
Rectangular PCBs are comfortable. Triangular panels joined into a 3D object are not. The LED D20 teaches that mechanical design and electronics design cannot be separated in compact projects. Connectors, cable bend radius, board edges, mounting points, battery placement, and heat all become part of the same puzzle.
2. Open Files Are Only the Beginning
Public design files are incredibly valuable, but they are not magic spells. Builders still need to understand the design, confirm revisions, order suitable components, and inspect assembly quality. Open-source hardware gives you the map; it does not carry you through the dungeon.
3. Tiny Components Reward Good Process
With fine SMD parts, organization matters. Label components. Work in sections. Inspect often. Do not build all 20 panels before testing one. That way lies sadness, or at least a long evening muttering at a multimeter.
4. Firmware Is Part of the Sculpture
The hardware makes the D20 physically possible, but the firmware gives it mood. A smooth animation can make the object feel alive. Poor timing can make it flicker like a haunted vending machine. The best LED projects treat software as part of the artwork, not an afterthought.
Who Should Build This?
The glowing LED D20 is best suited for experienced electronics hobbyists, embedded developers, PCB designers, and makers who enjoy ambitious builds. It is also a great study project for anyone interested in LED matrices, custom display hardware, FPGA-assisted output, or compact mechanical-electrical integration.
Beginners can still learn from it, even if they do not build the full version immediately. Start with a small RGB LED matrix. Learn how multiplexing works. Practice soldering surface-mount parts. Build a tiny cube or a simple triangular LED board. Once those skills feel comfortable, the D20 becomes less like a dragon and more like a dragon with a visible health bar.
Experience Section: What Building a Glowing LED D20 Feels Like
The experience of building a glowing LED D20 is less like assembling a gadget and more like managing a tiny engineering campaign. At first, the project feels intoxicatingly simple: twenty sides, lots of LEDs, cool animations. Then the details arrive wearing steel-toed boots. You realize each face is its own circuit board. Each board must be assembled cleanly. Each connector must fit. Each cable must bend without fighting the enclosure. The battery must fit inside. The firmware must refresh thousands of LEDs quickly enough to look smooth. Suddenly, the “cool dice lamp” has become a master class in systems thinking.
A realistic build experience starts at the research desk, not the soldering bench. You review the repository, inspect the bill of materials, compare board revisions, and make sure you are not accidentally ordering an outdated PCB version. This stage can feel slow, but it saves real money. In complex open-hardware projects, the smartest builders spend extra time reading before they spend extra money reordering parts.
The assembly phase is where patience becomes a tool. Working with tiny LEDs and SMD parts demands rhythm. Apply paste carefully. Place components deliberately. Reflow evenly. Inspect under magnification. Test early. Repeat. There is a strange satisfaction in watching a blank triangular PCB become a functional light panel. It feels like painting with components, except the paint can short out if you sneeze near it.
Debugging is where the project builds character. One face may be dim. One color channel may misbehave. A connector may not be seated perfectly. A solder bridge may hide between pads like a goblin in the wiring. The key is to isolate problems instead of panicking. Test one panel, one cable, one supply rail, and one signal path at a time. Good notes help. So does a sense of humor, because at some point you will probably ask a triangle why it hates you.
The first successful full-body animation is the reward. When all 20 faces light together, the object stops feeling like a collection of boards and becomes a single glowing artifact. That moment is why people build things the hard way. You are not just looking at LEDs; you are looking at geometry, code, power design, mechanical planning, and persistence wrapped into one luminous object.
For tabletop gamers, the final experience is even better. Place the LED D20 on a desk or gaming table and it immediately becomes a conversation piece. It does not need to replace a normal die. In fact, it probably should not be rolled across a table like a plastic dice set. Its best role is atmosphere: a magical status light, a critical-hit celebration machine, or a glowing centerpiece that says, “Yes, this campaign has production value.”
Conclusion
The glowing LED D20 with 2,400 LEDs is one of those maker projects that reminds us why hardware hacking is so addictive. It takes a familiar object, pushes it through serious engineering, and returns with something that feels both playful and technically impressive. The project is not easy, and that is part of its charm. It asks builders to understand PCB design, LED driving, embedded control, mechanical fit, soldering technique, and power management.
For most people, the LED D20 will be an inspiring project to admire, study, and maybe adapt into something simpler. For advanced makers, it is an invitation: the files exist, the concept has been proven, and the next glowing artifact is waiting for someone brave enough to build it. Whether you see it as a dice-inspired display, a futuristic lamp, or a tiny shrine to overengineering, one thing is clear: this D20 does not just roll for initiative. It rolls for illumination.
Note: This article is intended for educational and editorial use. Anyone attempting a similar build should follow proper electronics safety practices, use suitable tools for fine SMD assembly, verify PCB revisions before fabrication, and handle lithium-ion batteries with appropriate protection and charging circuitry.
