Make Your Own 8x8 LED Matrix

I've recently posted a tutorial about this project on YouTube explaining everything you can read on this article. You can watch it right below.

Introduction

Today I want to share a project I’m genuinely proud of: an 8×8 RGB LED matrix that I designed completely from scratch and had professionally assembled in a real factory.

And here’s the coolest part - you can chain multiple modules together and control them as if they were a single massive display.

This was my first time using PCB assembly services, so honestly I didn’t know if this was going to work, but hopefully it did (as you can see in the photos above).

And in this article, I’ll walk you through how I designed it, why it works, what I learned, and how you can build your own version too.

If you’ve ever thought, “I want to design real hardware, not just breadboard projects” - this one’s for you.

This project relies on PCB manufacturing and assembly services. I chose JLCPCB to manufacture it and will explain more about it later.

How the Matrix Works

This matrix is built around a very popular LED: the WS2812B.

If you’ve worked with addressable LEDs before, you probably recognize it immediately. Each LED contains a tiny integrated circuit that lets you control its color and brightness individually using just a single data wire.

That means:

• One data pin from your microcontroller
• Hundreds of LEDs controlled individually
• Full RGB per pixel

Arduino, ESP32, Raspberry Pi - anything that outputs a digital signal can control these LEDs.

Each WS2812B has four pins:

• 5V
• GND
• DIN (data in)
• DOUT (data out)

What makes them powerful is that each LED passes data along to the next one. You connect DOUT → DIN and create a long chain. The microcontroller sends a long stream of bits, and each LED grabs the part meant for it and forwards the rest.

The communication protocol has a scary name, NZR, but you don't need to learn it. Libraries like Adafruit NeoPixel handle all of this for you.

Once you understand this daisy-chain idea, the matrix design becomes simple.

Wire 64 LEDs in a chain, arrange them into a grid, and you get a display.

Designing the Matrix

This project started simple: I wanted a matrix that I could expand later - something modular, clean, and professional.

So I opened KiCad and started building the schematic.

The board contains:

• 64 × WS2812B LEDs
• 64 × 100nF ceramic capacitors
• A 4-pin connector (5V / GND / DIN / DOUT)

Why one capacitor per LED?

WS2812B LEDs are sensitive to power noise. Every time they switch colors, they generate small current spikes.

Without capacitors:

• LEDs may flicker
• Communication may glitch
• Long-term reliability drops

The fix is simple and standard practice:

• Place a 100nF capacitor next to each LED to absorb spikes locally.

Why no current-limiting resistor?

Because this LED already has internal current regulation.

You don’t need an external resistor like you would with discrete LEDs.

Expansion port

The 4-pin connector includes DOUT, which lets you chain another board directly.

• DOUT → DIN and you instantly double your display.

When the schematics was done, I knew the fun part was over and the scary part started.

I was going to let a factory assemble it.

By the way, I open-sourced this project.You can find the schematics, gerber files, and all other supplement materials in this GitHub repository.

Sponsor

This project is sponsored by JLCPCB, the company I trusted to manufacture and assemble this board.

If you're a maker like me, you know how much time a project can take. You need to do:

• Testing
• Debugging
• Redesigning
• Reordering parts
• More debugging
• Coding
• 3D design
• And much more

Now imagine also soldering 64 tiny RGB LEDs by hand alongside 64 very tiny capacitors.

No thanks. That's why I decided to let a PCB manufacturer to handle this.

With JLCPCB’s PCB assembly service, I simply:

• Uploaded my Gerber files
• Selected 2 layers
• Chose black PCB
• Enabled assembly
• Updated the BOM and placement file
• Refer to the two images below to select the appropriate manufacturing options

And right there - price, part availability, and delivery time.

A few days later, a box arrived at my door.

Inside were five fully assembled LED matrices.

This was my first ever factory-assembled board and I was nervous.

Would something be rotated? Missing? Dead?

But after opening the box and a quick visual inspection, I noticed the PCBs looked clean and professional - perfectly aligned LEDs, shiny solder joints, and no messy flux or imperfections. It didn’t look like a hobby project anymore. It looked like a real product.

If you want to build this exact board, I’ve stored all files in this GitHub repository. You can upload them directly to JLCPCB and order your own.

Huge thanks to JLCPCB for sponsoring this project and provinding high-quality PCB assembly for an affordable price.

PCB Design & Power Considerations

Now let’s talk about engineering decisions.

Current draw

At full brightness, 64 WS2812B LEDs can draw up to 4A.

That’s a lot of power. It would required 2 mm traces, but thick traces everywhere would have made the board huge. So I designed it explicitly to handle:

• 2A maximum or 50% brightness

And because of that, the trace widths are:

• Data lines: 0.3 mm
• Power lines: 0.8 mm

This keeps the board compact and electrically safe.

Important warning

DO NOT power this from an Arduino 5V pin unless the brightness is very low.

Use:

• An external 5V power supply
• Common ground with the Arduino
• Brightness ≤ 50%

Testing

I connected the first board to my Arduino, uploaded the test sketch (animations.ino), and powered it up.

Every LED turned on exactly as expected. No dead pixels, strange colors or flickering.

This is something I love about electronics.

You think about an idea, sketch it, design it, fight with the software and one day a project that existed only in your head suddenly becomes a real physical thing sitting in front of you, doing exactly what you imagined.

That feeling never gets old. And the best part is that you can do it too. You can invent anything you set your mind to.

And now that the first test worked, I chained two modules together. And once again everything worked perfectly. The matrix behaved like a single giant panel, just like I planned.

That’s the magic of modular design.

Code

Driving this matrix from a microcontroller is much easier than you might expect.

For this project, I used an Arduino Uno, but the exact same code works with almost any board that can control WS2812B LEDs - ESP32, Raspberry Pi, etc. You just need the right library.

The entire sketch is built using the Adafruit NeoPixel library. This library takes care of all the hard parts for you: timing, communication, and converting colors into signals the LEDs understand. All you really have to do is tell it how many LEDs you have and which pin they’re connected to.

In the code, you define:

• The number of LEDs in the matrix
• The data pin connected to the board
• The maximum brightness level

From there, everything becomes software.

You can tell each pixel:

• What color it should be
• How bright it should be
• When it should change

That means once the hardware is done, the entire display becomes a programming playground.

For testing, I wrote a simple sketch with different animations:

• Color wipes
• Smooth rainbows
• Wave effects
• Sparkles
• And solid color tests

These aren’t just visual effects, they’re also diagnostic tools. The code helps confirm that:

• Every LED is working
• Data is flowing correctly
• Power is stable across the board

If something flickers, freezes, or behaves strangely, it’s usually either a wiring issue or a power issue, and animations make that obvious immediately.

By the way, if you have trouble coding Arduino sketches, I published a tutorial all about Arduino programming for beginners. I recommend you check it out to level up your skills.

Conclusion

And that’s it for today’s project.

I hope this article inspired you to design something of your own. You don’t have to start big - just build something. The moment you see a PCB you designed show up at your door, fully assembled and working, you'll feel amazed.

You can invent anything you set your mind to. You just need to start.

And before you leave Hackster, check out this another article in which I teach about how to build a two-way communication system with LoRa modules and Arduino.

Thanks for reading, and I’ll see you in the next one.