FastLED/FastLED

Transform any microcontroller into an LED powerhouse.

Drive 30,000+ LEDs on high-end devices • Sub-$1 compatibility on tiny chips • Background rendering for responsive apps • Nearly every LED chipset supported • #2 most popular Arduino library

#include <FastLED.h>
#define NUM_LEDS 60
CRGB leds[NUM_LEDS];

void setup() { 
  FastLED.addLeds<WS2812, 6>(leds, NUM_LEDS); 
}

void loop() {
  leds[0] = CRGB::Red; FastLED.show(); delay(500);
  leds[0] = CRGB::Blue; FastLED.show(); delay(500);
}

✅ Works on Arduino, ESP32, Teensy, Raspberry Pi, and 50+ other platforms

See our Cookbook for tutorials and walkthroughs →

The FastLED Cookbook provides practical guides, step-by-step examples, and copy-paste recipes to help you create stunning LED effects - from your first blink to advanced animations.

🎯 Performance: Zero-cost global brightness • High-performance 8-bit math, memory efficient on platforms that need it. 🔧 Developer Experience: Quick platform switching • Extensive examples • Active community support

FastLED's codebase is organized into several major areas. Each directory contains a README with detailed documentation:

• 🎵 Audio Reactive LEDs
• ⏱️ Async Tasks Instead of delay()
• 🆕 Latest Feature
• ⭐ Community Growth
• 🆕 Latest Features
• 🌍 Platform Support
• 📦 Installation
• 📚 Documentation & Support
• 🎮 Advanced Features
• 🤝 Contributing

📊 Detailed Build Status

The Smoke Build badge above tracks build.yml, which compiles a small default example set across a subset of boards. Every per-board build badge below proves compile coverage only; it does not validate hardware or timing. The QEMU and AVR8JS badges are the explicitly labelled emulation exceptions. Most per-board workflows compile that board's full example sweep, while a narrower set is called out next to the affected badge. A per-board badge can therefore be red while the smoke badge is green.

ESP32 (QEMU):

AVR (AVR8JS):

Core Boards:

SAM3X (Arduino core):

SAMD (Adafruit core unless noted):

The Arduino Zero badge uses upstream ArduinoCore-samd. The other SAMD badges use Adafruit's fork, which supplies SAMD51 support.

SAME53 (Teknic core):

ClearCore deliberately compiles Blink only against the pinned Teknic Arduino core.

ATtiny Series:

ATtiny4313 has limited memory, so its workflow compiles only WS2812 Blink and APA102 examples.

Standard Models:

Special Features:

Core coverage: all five badges use Adafruit's nRF52 core. Both Xiao variants and the DK/SuperMini workflows compile against the pinned nrf52840_dk_adafruit BSP target recorded in ci/boards.py; they do not cover Arduino's mbed core.

*Beta support added in 3.10.2

Core coverage: these ststm32 builds use STM32duino except the explicitly configured Maple-compatible target; Arduino GIGA uses its mbed core. The UNO Q badge is an STM32duino compile proxy, as documented in ci/boards.py.

*LPC804 and LPCXpresso804 are currently failing on master. These builds had no badge before, so the breakage was not visible from this page.

*MGM240 (EFR32MG24) support for Arduino Nano Matter, SparkFun Thing Plus Matter, and Seeed Xiao MG24 Sense boards

All three badges use Earle Philhower's Arduino-Pico core; none exercises Arduino's Mbed OS RP2040 core.

ESP8266:

ESP32 Classic:

ESP32 S-Series:

ESP32 C-Series:

ESP32 Advanced:

RGBW:

Special Features:

IDF Variants:

Legacy:

ESP32-C2 support was added in 3.9.10. See the Espressif compatibility evaluation.

x86:

WebAssembly:

STM32:

Core Platforms:

Teensy Platforms:

Tracks compilation speed and performance of FastLED header files across different platforms.

FastLED includes an automated research and validation framework for developing hardware drivers using real devices. An AI agent edits code, flashes firmware, and uses an RX device to score LED signal accuracy against expected timings — iterating until the driver works.

#!/usr/bin/env bash

PROMPT="Use the auto research framework to implement I2S driver for esp32dev
on the attached device. Don't stop until it works."

# solder pin 1 to pin 2 on esp32dev, then attach it to the computer through the USB port.
git clone https://github.com/fastled/fastled
cd fastled

claude --dangerously-skip-permissions -m "$PROMPT"

# now get a cup of coffee and come back in an hour

This works because FastLED's drivers are split into two layers: a platform-neutral channel driver (waveform generation, buffering, scheduling) that can be unit tested in isolation, and a thin platform-specific peripheral layer (ESP32 RMT, PARLIO, I2S, LCD_CAM) that just transmits the bitstream. The AI agent is effective because most complex logic lives in the testable layer, while the hardware-specific code is small enough to reason about at the datasheet level.

Turn sound into light with a fluent, callback-driven API. Connect an I2S microphone, register callbacks for beats, bass, percussion, silence — and FastLED handles the rest. Audio is auto-pumped during FastLED.show(), so there's no manual update loop.

#include "FastLED.h"

#define NUM_LEDS 60
CRGB leds[NUM_LEDS];
fl::shared_ptr<fl::AudioProcessor> audio;

void setup() {
    FastLED.addLeds<WS2812B, 2, GRB>(leds, NUM_LEDS);

    // One line: create mic + auto-pump task
    auto config = fl::AudioConfig::CreateInmp441(/*WS*/ 7, /*SD*/ 8, /*CLK*/ 4, fl::Right);
    audio = FastLED.add(config);

    // React to music
    audio->onBeat([] { fill_solid(leds, NUM_LEDS, CRGB::White); });
    audio->onBass([](float level) {
        fill_solid(leds, NUM_LEDS, CHSV(level * 160, 255, 255));
    });
    audio->onSilenceStart([] { fill_solid(leds, NUM_LEDS, CRGB::Black); });
}

void loop() {
    fadeToBlackBy(leds, NUM_LEDS, 20);
    FastLED.show();  // Audio is auto-pumped here
}

Platforms: ESP32 (I2S / PDM) and Teensy. Code compiles on all platforms — callbacks are simply inert where hardware isn't available.

More examples & full API reference: src/fl/audio/README.md

Run several independent animations, sensor reads, and network polls out of one loop() — no blocking, no hand-rolled millis() bookkeeping. Each task is a small callback with its own schedule. fl::task::run() executes whichever tasks are due and returns. Adding a feature means adding a task, not rethreading the timing of everything already there.

#include <FastLED.h>
#include "fl/task/task.h"

#define NUM_LEDS 60
CRGB leds[NUM_LEDS];

void setup() {
    FastLED.addLeds<WS2812, 6>(leds, NUM_LEDS);

    // Two blinkers on independent schedules
    fl::task::every_ms(700).then([] {
        static bool on = false;
        on = !on;
        leds[0] = on ? CRGB::Red : CRGB::Black;
    });

    fl::task::every_ms(400).then([] {
        static bool on = false;
        on = !on;
        leds[1] = on ? CRGB::Blue : CRGB::Black;
    });

    // One task owns the hardware push
    fl::task::at_framerate(60).then([] { FastLED.show(); });
}

void loop() {
    fl::task::run();  // run whatever is due, then return
}

Platforms: the scheduler runs everywhere, down to AVR. Coroutines and await() — for sequential async like "fetch, wait for the reply, then apply it" — need an RTOS-capable target (ESP32, Teensy 4.x, host/WASM builds).

More examples & full API reference: src/fl/task/README.md

Dynamically control LED hardware drivers at runtime through the familiar FastLED API. Switch between RMT, SPI, and PARLIO drivers without recompiling - perfect for debugging, optimization, and adapting to runtime conditions.

Platform Support: API is available on all platforms for code compatibility. Full functionality (multi-driver switching) is ESP32-only. Non-ESP32 platforms have safe no-op implementations.

// Force RMT driver exclusively (disables SPI, PARLIO, and future drivers).
// Typed fl::Bus form — fl::Bus::RTM would be a compile error.
FastLED.setExclusiveDriver(fl::Bus::RMT);

// Or selectively enable/disable
FastLED.setDriverEnabled("SPI", false);    // Disable SPI
FastLED.setDriverEnabled("PARLIO", true);  // Enable PARLIO

// Query driver state
if (FastLED.isDriverEnabled("RMT")) {
    Serial.println("RMT driver is active");
}

// Inspect all registered drivers
auto drivers = FastLED.getDriverInfo();
for (const auto& driver : drivers) {
    FL_WARN(driver.name << ": priority=" << driver.priority
            << " enabled=" << (driver.enabled ? "YES" : "NO"));
}

Key Features:

• 🎛️ Runtime switching - Change drivers on-the-fly without recompiling
• 🔍 Driver inspection - Query available drivers, priorities, and states
• 🔮 Forward-compatible - setExclusiveDriver() automatically handles future drivers
• ⚡ Immediate effect - Changes apply on next FastLED.show() call
• 🔄 Automatic fallback - If a driver fails, automatically tries next priority

Use Cases:

• Debug driver-specific issues by isolating to one driver
• Optimize for Wi-Fi performance (RMT handles interrupts better)
• Dynamically switch based on runtime conditions (Wi-Fi status, power modes)
• Test new drivers without code changes

Documentation: ESP32 Runtime Driver Control • Release Notes • Example: AutoResearch.ino

New 16-bit RGBW LED chipset support for ARM M0/M0+ platforms (SAMD21/SAMD51). The UCS7604 is a high-resolution 4-channel LED driver with configurable bit depth (8/12/14/16-bit) and dual data rates (800kHz/1.6MHz).

FastLED.addLeds<UCS7604, DATA_PIN, GRB>(leds, NUM_LEDS);  // 16-bit mode, 800kHz

⚠️ Beta Status: Currently ARM M0/M0+ only. Hardware validation ongoing. See examples/UCS7604_Basic for usage.

Hardware-accelerated parallel LED output for ESP32-P4 using the dedicated RGB LCD peripheral. Drive up to 16 WS2812 LED strips simultaneously with DMA-backed, zero-CPU-overhead transmission.

// Enable RGB LCD driver in platformio.ini
build_flags = -DFASTLED_ESP32_LCD_RGB=1

// Use GPIO39-54 (safe range for ESP32-P4)
FastLED.addLeds<WS2812, 39, GRB>(leds[0], NUM_LEDS);
FastLED.addLeds<WS2812, 40, GRB>(leds[1], NUM_LEDS);
// ... up to 16 parallel strips

Key Features:

• 🚀 Up to 16 parallel strips - Hardware-timed output with nanosecond precision
• ⚡ Zero CPU overhead - DMA-driven frame buffer transmission
• 🔒 GPIO safety - Automatic validation prevents boot failures from strapping pins
• 💾 PSRAM support - Automatic frame buffer allocation for large installations
• 🔄 Async operation - Non-blocking updates via VSYNC interrupt callbacks

⚠️ Experimental Status: Code complete and passes all reviews, but untested on hardware (ESP32-P4 boards limited availability). Community testing welcome!

Documentation: RGB LCD Research • Migration Guide • Release Notes • Example Code

See examples/FestivalStick/FestivalStick.ino

Advanced animation framework for complex LED visualizations and effects.

Multi-layer compositing & time-based animation control for tech-artists.

📺 Live Demos • 📋 Full Changelog

FastLED.addLeds<HD107S, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);

FastLED supports 50+ platforms! From sub-$1 ATtiny chips to high-end Teensy 4.1 with 50 parallel outputs.

• 🎯 Arduino + PlatformIO Starter - Best of both worlds, works with both IDEs
• 🚀 FastLED Examples - 100+ ready-to-run demos
• 🌐 Web Compiler - Test in your browser

Need Help? Visit r/FastLED - thousands of knowledgeable users and extensive solution history!

GitHub issues track behavior owned by FastLED. If a problem appears only when using an adapter library such as FastLED_NeoMatrix, report it to that adapter's maintainer and include a minimal FastLED-only reproduction when possible. Messages such as #pragma message: FastLED version ... are informational build output, not warnings or errors.

If a steady color produces random pixels, flashes, or resets, first rule out an electrical problem. Color-dependent failures are often load-dependent: lighting two channels draws more current than lighting one, so a marginal supply can fail only for particular RGB values.

1. Prove the power path. Power the strip from a regulated 5 V supply sized for the LED load; do not route strip current through a development board's linear regulator. A regulator marked 5.0 V cannot produce regulated 5 V from a 5 V USB input because it needs voltage headroom.
2. Use a common ground. Connect the controller ground, LED ground, and external-supply ground together with short, low-resistance wiring.
3. Stabilize the strip input. Add bulk capacitance across 5 V and ground at the strip, keep the data wire short, and place a 33–220 Ω resistor in series with data near the controller.
4. Reduce the test load. Start with one LED at low brightness and a fixed solid color, then increase LED count and brightness. If corruption begins as load rises, measure the 5 V rail at the strip while it is lit.
5. Check logic levels. When a 3.3 V controller drives a 5 V strip, use a 74HCT-family level shifter if the strip does not reliably recognize the data signal.

Once the same minimal sketch and wiring work on a known-good controller and power supply, include that A/B result in a FastLED bug report.

Note: The new LCD driver is recommended over I2S for better Serial debugging support and memory efficiency. ESP32-P4 supports both RGB and I80 LCD modes. Some ESP32 Arduino core versions (3.10+) have compatibility issues with I2S. Older versions work better - see issue #1903

Applies to: Teensy/ESP32/etc. driving WS2812/WS2813/SK6812 (1-wire) and APA102/clocked chips

Grounds → ground bus → Teensy GND
Level shifters: 2× 74HCT245 (16 channels), powered at 5V
Per channel: Buffer → 33–100Ω → twisted pair → strip DIN/GND
At strip start: 1000µF cap across +5V/GND
Power injection as needed; keep data/power runs separate

Custom shift register boards can achieve extreme parallel output:

• ESP32DEV: 120-output virtual driver
• ESP32-S3: 120-output S3 driver

#include <FastLED.h>

CRGB leds[NUM_LEDS];
void setup() {
    // ObjectFLED is used automatically on Teensy 4.x
    FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, NUM_LEDS);
}

#define FASTLED_NOT_USES_OBJECTFLED
#include <FastLED.h>

#define FASTLED_USES_OBJECTFLED
#include <FastLED.h>

#define USE_WS2812SERIAL
#include <FastLED.h>

FastLED.addLeds<WS2812SERIAL, /* DATA_PIN */, GRB>(leds, NUM_LEDS);

#define FASTLED_ESP32_LCD_DRIVER
#include <FastLED.h>

CRGB leds1[NUM_LEDS];
CRGB leds2[NUM_LEDS];

void setup() {
    // Standard FastLED API - LCD driver auto-selected
    FastLED.addLeds<WS2812, 2>(leds1, NUM_LEDS);  // WS2812 on pin 2
    FastLED.addLeds<WS2811, 4>(leds2, NUM_LEDS);  // WS2811 on pin 4 (slower timing)
}

void loop() {
    // Your LED code here
    FastLED.show();
}

#define FASTLED_USES_ESP32S3_I2S
#include <FastLED.h>

FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, NUM_LEDS);

#define FASTLED_ESP32_I2S
#include <FastLED.h>

FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, NUM_LEDS);

#define FASTLED_ESP32_I2S_NUM_DMA_BUFFERS 4

[env:esp32]
platform = espressif32
board = esp32dev
framework = arduino
lib_deps = fastled/FastLED
build_flags =
    -D FASTLED_RMT5=0

// Enable/disable specific drivers
FastLED.setDriverEnabled("RMT", true);      // Enable RMT driver
FastLED.setDriverEnabled("SPI", false);     // Disable SPI driver

// Enable only one driver (disables all others, including future drivers).
// Typed: fl::Bus::RTM would be a compile error.
FastLED.setExclusiveDriver(fl::Bus::RMT);   // Use only RMT

// Query driver state
bool rmtEnabled = FastLED.isDriverEnabled("RMT");
int driverCount = FastLED.getDriverCount();

// Get detailed info about all drivers
auto drivers = FastLED.getDriverInfo();
for (const auto& driver : drivers) {
    Serial.print(driver.name);              // "RMT", "SPI", "PARLIO"
    Serial.print(": priority=");
    Serial.print(driver.priority);          // Higher = preferred
    Serial.print(" enabled=");
    Serial.println(driver.enabled);         // true/false
}

void setup() {
    // Test with only RMT to isolate driver issues
    FastLED.setExclusiveDriver(fl::Bus::RMT);
    FastLED.addLeds<WS2812, PIN, GRB>(leds, NUM_LEDS);
}

void setup() {
    // Disable SPI if it conflicts with Wi-Fi on your board
    FastLED.setDriverEnabled("SPI", false);
    // RMT or PARLIO will be used instead
}

void loop() {
    if (WiFi.status() == WL_CONNECTED) {
        // Use RMT when Wi-Fi is active (more interrupt-tolerant)
        FastLED.setExclusiveDriver(fl::Bus::RMT);
    } else {
        // Use faster SPI when Wi-Fi is off
        FastLED.setExclusiveDriver(fl::Bus::SPI);
    }

    // Your LED code...
    FastLED.show();
}

void setup() {
    Serial.begin(115200);

    // List all registered drivers
    Serial.println("Available LED drivers:");
    auto drivers = FastLED.getDriverInfo();
    for (const auto& driver : drivers) {
        Serial.printf("  %s: priority=%d enabled=%s\n",
            driver.name.c_str(),
            driver.priority,
            driver.enabled ? "YES" : "NO");
    }
}

#include <FastLED.h>

CRGB leds[NUM_LEDS];
void setup() {
    // GPIO-based controller on pin 7
    FastLED.addLeds<EZWS2812_GPIO, 7, GRB>(leds, NUM_LEDS);
}

#define FASTLED_USES_EZWS2812_SPI  // MUST be before #include
#include <FastLED.h>

CRGB leds[NUM_LEDS];
void setup() {
    // SPI-based controller (consumes hardware SPI)
    FastLED.addLeds<EZWS2812_SPI, GRB>(leds, NUM_LEDS);
}

Note: All I2S lanes must share the same chipset/timings. If per-lane timing differs, consider using the RMT driver instead.

FastLED supports virtually every LED chipset available:

RGBW Support: WS2814 automatically emits fixed R,G,B,W output; explicit setRgbw() calls warn and are ignored • Overclocking: WS2812 up to 70% speed boost

More details: Chipset Reference Wiki

Usage example:

// For WS2812B-V5 or WS2812B-Mini-V3 strips
FastLED.addLeds<WS2812BV5, DATA_PIN, GRB>(leds, NUM_LEDS);
FastLED.addLeds<WS2812BMiniV3, DATA_PIN, GRB>(leds, NUM_LEDS);

// WS2814 automatically enables RGBW output in R,G,B,W byte order.
FastLED.addLeds<WS2814, DATA_PIN, RGB>(leds, NUM_LEDS);

// WS2818 is an RGB chipset; GRB is the common strip color order.
FastLED.addLeds<WS2818, DATA_PIN, GRB>(leds, NUM_LEDS);

WS2814's DIN2 pin is an auxiliary input used by the chipset's backup-data scheme, not a second FastLED output. Wire it according to the strip or module datasheet; no second data-pin template argument is required.

Power WS2814 LEDs from a suitable external 5 V supply, connect the supply and microcontroller grounds together, and translate 3.3 V data to 5 V with a 5 V HCT/AHCT buffer such as a 74AHCT125.

WS2818's BI/BIN pin is the backup input, not a second FastLED output. Follow the strip or module datasheet for its backup-data and power wiring, share a common ground with the microcontroller, and use the logic level specified by that hardware.

#define LED_TYPE APA102HD  // Enables hardware gamma correction
void setup() {
  FastLED.addLeds<LED_TYPE, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
}

Read more: APA102 HD Documentation • Rust Implementation

#define LED_TYPE HD108  // 16-bit per channel with built-in gamma correction
void setup() {
  FastLED.addLeds<LED_TYPE, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
}

HD108/NS108 Features:

• 16-bit per channel (65,536 levels) vs APA102's 8-bit (256 levels)
• Built-in gamma correction (gamma 2.8) for smooth perceptual brightness transitions
• Higher PWM frequency (27 kHz) reduces visible flicker compared to APA102's ~20 kHz
• 40 MHz max clock (25 MHz default for stability on long strips)
• 5-bit brightness control (0-31) per LED for current limiting
• Manufacturer: Newstar LED (NS108 = HD108, same chip)
• No SD (standard definition) option - All HD108s use gamma correction built-in

Comparison with APA102:

Read more: See detailed protocol documentation in src/chipsets.h:1040-1183

Ready to contribute? FastLED welcomes code contributions, platform testing, documentation improvements, and community support.

In Memory of Daniel Garcia Daniel Garcia, the brilliant founder of FastLED, tragically passed away in September 2019 in the Conception dive boat fire alongside his partner, Yulia. This heartbreaking loss was felt deeply by the maker and developer community, where Daniel's contributions had left an indelible mark.

Daniel was more than just a talented programmer; he was a passionate innovator who transformed the way creators interacted with LED technology. His work on FastLED brought high-performance LED control to countless projects, empowering developers to craft breathtaking installations.

In his personal life, Daniel was known for his kindness and creativity. His pride in FastLED and the vibrant community it fostered was a testament to his dedication to open-source development and his commitment to helping others bring light into the world.

While Daniel is no longer with us, his legacy continues through the FastLED library and the countless makers who use it. The community he built serves as a living tribute to his ingenuity, generosity, and the joy he found in sharing his work with the world.

Zach Vorhies, the current main contributor to FastLED, briefly worked with Dan in 2014 in San Francisco and was an avid user of the FastLED library for over 13 years. After Daniel Garcia’s untimely passing, Zach stepped up to ensure FastLED’s continued growth and development.

Zach has this to say about FastLED:

"The true power of FastLED lies in its ability to transform programmers into LED artists. Free space becomes their canvas; bending light is their medium. FastLED is a collective effort by programmers who want to manifest the world that science fiction writers promised us. -- To contribute code to FastLED is to leave behind a piece of something immortal."

💫 In memory of Daniel Garcia and the vision that transforms programmers into LED artists

To stay updated on the latest feature releases, please click the Watch button in the upper right ""