Arduino WS2812 8x8 Matrix: Play Pixel Art Animations | ShillehTek

August 23, 2026 5 views

Project

Build an Arduino WS2812 8x8 LED matrix pixel art frame that turns tiny images into smooth FastLED animations, using parts you can source from ShillehTek.

1 hr Beginner4 parts

Project Overview

Arduino + WS2812 8x8 LED Matrix Pixel Art Display: Build a desktop pixel art frame that plays your own 8x8 animations (spaceships, countdowns, explosions, and more) by converting images into Arduino code with a free tool. The original build was hand-soldered from 64 LEDs, but a ready-made 8x8 matrix module lets you skip straight to the fun part.

Time: 1-2 hours (with the pre-built matrix; a weekend if you solder your own)
Skill level: Beginner
What you will build: A self-contained animated pixel display with a diffused grid face, driven by an Arduino and the FastLED library.

Finished Arduino-driven 8x8 WS2812 LED matrix pixel art display mounted as a desktop frame — The finished frame: 64 pixels of desktop art.

Parts List

From ShillehTek

CJMCU-64 8x8 WS2812 RGB LED Matrix Module - 64 addressable LEDs already wired in the zig-zag layout this project expects
Arduino Nano V3.0 Pre-Soldered (or an Uno) - runs the FastLED sketch and drives the matrix
MB102 Breadboard Power Supply - provides 5V power since 64 RGB LEDs at full white need more current than a USB port
Dupont Jumper Wires - quick wiring between the Arduino, power, and matrix

External

Thin cardboard for the pixel grid, baking paper as the diffuser
An enclosure (the original repurposed an ice-cream tub)
Hot glue gun; a 5V supply for standalone use

Note: The hand-soldered route (a jig + 64 individual WS2812 LEDs) is documented below, but the pre-wired matrix module is electrically identical and saves an entire evening of soldering.

Step-by-Step Guide

Step 1 - The Matrix (Buy It or Build It)

Goal: Get 64 addressable pixels in an 8x8 grid.

What to do: The original build soldered 64 loose WS2812 LEDs using a homemade jig, joining them in a zig-zag pattern left-to-right, then pressed them into a cardboard backing. That zig-zag wiring is exactly how pre-made matrix modules are laid out internally, so if you use the CJMCU-64 board, your data order matches this project's code as-is.

Homemade soldering jig holding individual WS2812 LEDs while building an 8x8 matrix — The DIY route: a jig holds each LED while soldering.

WS2812 LEDs wired in an 8x8 zig-zag data path showing row-by-row layout — Zig-zag data path, row by row, matching typical pre-built matrix wiring.

Hand-soldered WS2812 LED grid pressed into a cardboard backing for an 8x8 matrix — The soldered grid pressed into a cardboard carrier.

Expected result: A working 8x8 LED plane, bought or built.

Step 2 - Build the Pixel Grid and Diffuser

Goal: Turn 64 points of light into 64 square pixels.

What to do: Slot strips of thin cardboard into a square grid (one cell per LED) and hot-glue it over the LEDs. Cover the face with baking paper to diffuse each cell into a soft, even square.

Cardboard pixel grid insert used to separate each LED into an 8x8 pixel cell — The slotted cardboard grid that separates the pixels.

Cardboard pixel grid hot-glued onto an 8x8 WS2812 LED matrix panel — Grid glued down over the matrix.

Baking paper diffuser applied over an 8x8 WS2812 LED matrix to soften each pixel — Baking paper makes a simple, effective diffuser.

Expected result: Crisp square pixels instead of bare LED points.

Step 3 - Box It Up

Goal: Make it a self-contained desk unit.

What to do: Mount everything in a shallow enclosure (the original used an ice-cream tub) with a power switch and a hole for the 5V feed. Place the Arduino inside so the whole unit becomes a standalone gadget you can plug in.

Enclosure for an 8x8 WS2812 pixel art display showing power switch and cable pass-through — Enclosure with power switch and cable pass-through.

Assembled 8x8 WS2812 pixel art display face ready for Arduino animations — The assembled face, ready for animations.

Arduino Nano installed inside the enclosure to control a WS2812 8x8 LED matrix — The controller tucks inside for a self-contained unit.

Expected result: A finished frame that needs only 5V.

Step 4 - Turn Any Image into Arduino Code

Goal: Convert 8x8 artwork into color arrays.

What to do: Draw (or downscale) an image to exactly 8x8 pixels, then open it in the free LCD Image Converter (SourceForge). Configure: Options Convert, set Block size to 24-bit on the Image tab, and Type to Color on the Prepare tab. Click Show Preview, copy the generated array, and paste it into the sketch. Each value is one pixel's color.

LCD Image Converter opening an 8x8 pixel image for a WS2812 LED matrix animation — Open your 8x8 image in LCD Image Converter.

LCD Image Converter settings configured for 24-bit color blocks to generate Arduino arrays — Conversion settings: 24-bit blocks, Color type.

Copying the generated 64-value color array from LCD Image Converter preview for Arduino FastLED — Show Preview, copy the array, then paste into your sketch.

Expected result: A 64-value color array for every frame of your animation.

Step 5 - Flash the FastLED Player

Goal: Play your frames on the matrix.

What to do: Install FastLED, paste your frame arrays into the sketch (stored in flash with PROGMEM so you can fit many frames), and upload to your Arduino:

Code:

#include <avr/pgmspace.h>   // store frames in flash with PROGMEM
#include "FastLED.h"

#define NUM_LEDS 64
#define DATA_PIN 9

CRGB leds[NUM_LEDS];

// One 8x8 frame from LCD Image Converter (64 x 24-bit colors)
const long frame1[] PROGMEM = {
  0x000000, 0xff0000, 0x000000, /* ... 64 values total ... */
};

void setup() {
  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
  FastLED.setBrightness(40);
}

void loop() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = pgm_read_dword(&(frame1[i]));
  }
  FastLED.show();
  delay(500);
  // add frame2, frame3... and cycle them for animation
}

Arduino IDE showing a PROGMEM frame array pasted for a WS2812 8x8 LED matrix using FastLED — Each converted frame becomes one PROGMEM array.

Expected result: Your artwork glowing on the matrix.

Step 6 - Make Animations

Goal: Bring the frame to life.

What to do: An animation is just multiple frames played in order. Convert each 8x8 image, add its array, and cycle through them in loop(). The original runs spaceship flights, 3-2-1-0 countdowns, and explosion sequences.

8x8 WS2812 LED matrix showing first light after uploading Arduino FastLED code — First light.

Close-up of an 8x8 WS2812 pixel art animation frame displayed from Arduino — Frames from the built-in animations.

8x8 WS2812 LED matrix showing a spaceship animation frame driven by Arduino — A spaceship mid-flight.

8x8 WS2812 pixel display showing countdown digits as an Arduino animation — Countdown digits.

8x8 WS2812 LED matrix displaying a custom pixel art animation created from images — Whatever you draw next.

Finished Arduino-powered 8x8 WS2812 pixel art frame glowing with animated graphics — The finished frame running animations.

Expected result: A personal pixel-art gallery you can reprogram any time.

Conclusion

With an Arduino, an 8x8 WS2812 LED matrix, a simple cardboard grid, and baking paper diffusion, you can build a charming animated pixel-art display. The image-to-code workflow means you can put your own art on the matrix without manually mapping pixel coordinates.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Credits

All photos and images in this tutorial are credited to mpg28 on Hackster.io. The original guide by mpg28 served as the reference for this ShillehTek version. We thank them for their excellent work in the maker community.