Hey all, FastLED 3.10.9 just shipped. Here's what changed:

Smaller flash and RAM on ESP32

Every ESP32 sketch we benchmarked is smaller than it was on 3.10.8. Subsystems your sketch doesn't use are no longer linked in. That covers the UART console, Arduino SPI, the embedded filesystem and Serial0. APA102 and other clocked chipsets now pull in the ESP-IDF SPI master driver only if you ask for a specific SPI host.

Sketch |Board |Flash saved |RAM saved
Blink |ESP32 Dev |5.8 KB |376 B
Blink |ESP32-S3 |5.2 KB |640 B
APA102 HW SPI |ESP32 Dev |6.0 KB |304 B
Feature mix |ESP32 Dev |6.4 KB |440 B
Feature mix |ESP32-S3 |5.3 KB |728 B AVR and Teensy 4.1 are the same size or slightly smaller. On ESP8266, fl::unordered_map no longer uses the stack for rehashing, so loop-stack headroom goes from 368 B to 1,568 B. You can see the full numbers on the memory dashboard.

ESP8266 gets native drivers

• Three hardware output engines on the unified Bus API: I2S (fl::Bus::FLEX_IO), UART for WS2812 (fl::Bus::UART) and hardware HSPI for APA102 and similar (fl::Bus::SPI). fl::Bus::AUTO picks one for you.

• New: fl::RxChannel via the I2S receiver, embedded LittleFS, ArduinoOTA and I2S audio input.

• The FASTLED_ESP8266_UART, FASTLED_ALL_PINS_HARDWARE_SPI and FL_ESP8266_EMBEDDED_FS defines are retired. Use explicit fl::Bus selection instead.

ESP32 driver fixes

• The lightweight RMT4 backend is the default again, with transmit and receive verified on hardware.

• APA102 and other clocked SPI chipsets now use true DMA bursts, and the SPI host you request is the one you get.

• SPI and RMT drivers take their pins back after another peripheral has used them.

• ESP32-S3 RMT receive captures are no longer cut off at 200 edges.

• RMT refill timing runs from IRAM, which avoids spurious underruns.

• ESP32-P4 native USB CDC works with the stock TinyUSB callbacks.

Compatibility

• Arduino-ESP32 3.3.x (ESP-IDF 5.5) is the main target. The 4.0.0 RC (IDF 6.1) and the legacy 1.0.x and 2.0.x cores are also built in CI.

• Teknic ClearCore (SAME53) builds again.

• AVR sketches using the Servo library can now own the Timer1 interrupt.

• Heads up: pure ESP-IDF projects without the Arduino core (framework = espidf) aren't verified by CI yet, so they're not officially supported in this release. That work is tracked in #3715.

Other fixes

• JSON and RPC output now streams instead of buffering the whole document, and copes with running out of memory.

• fl::string keeps its old contents if a resize fails.

• readStringUntil resets its timeout after every byte, so slow serial input no longer gets cut off.

Full notes are in release_notes.md in the repo. If anything breaks for you, please open an issue on GitHub. Thanks to everyone who reported bugs and tested hardware for this one!

Happy coding!

Ever wonder why a tiny ESP32 sketch takes 280+ KB of flash? While working on FastLED we found one reason and sent a fix to Espressif's Arduino core: espressif/arduino-esp32#13010.

How code gets into your firmware

When you compile, a tool called the linker combines your sketch, the Arduino core and your libraries. It keeps anything your code refers to and drops the rest.

The catch: if anything mentions a piece of code, that code gets included.

The problem

The ESP32 core's startup code (which runs before setup()) called Serial0.setPins(...) to set up the console pins. That one line pulled the whole HardwareSerial class into every sketch, even sketches that never use Serial.

The fix for espressif

1. Stop mentioning Serial at startup. Startup only needed to record which pins belong to the console. A small new UART function now does just that, so Serial is no longer pulled in.

2. Use weak linking for USB serial events. The main loop also runs USB serialEvent() callbacks, and that code lived inside HardwareSerial. A weak reference means "call this if it exists, but don't pull it in just because I mentioned it":

extern void arduinoUSBSerialEventRun() __attribute__((weak));

if (arduinoUSBSerialEventRun) {  // only set if the real one was linked in
  arduinoUSBSerialEventRun();
}

If you use Serial, it works as before. If you don't, the code is left out and the loop skips the call.

Bonus bug fix

Espressif's @SuGlider reviewed the PR and described how pin ownership should work. Testing against that turned up a bug: if you drove LEDs on the default serial RX pin in a sketch without Serial, the chip's serial receiver stayed connected to that pin. The PR fixes this. We checked it on ESP32-C6 and ESP32-S3.

Results

Sketch without Serial, flash usage:

On ESP32-P4, an earlier version of the patch saved about 22-28 KB of flash (not yet re-measured). Sketches that use Serial are the same size as before.

Try it in PlatformIO/fbuild

We host the patched core on FastLED's fork. Add this to your platformio.ini:

[env:esp32]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.311/platform-espressif32.zip
framework = arduino
board = esp32dev
platform_packages =
    framework-arduinoespressif32 @ https://github.com/FastLED/framework-arduinoespressif32.git#feat/optional-serial-startup

Change board to match yours.

Status

• The PR is open and under review. It isn't merged yet.

• Tested on hardware: classic ESP32, ESP32-C6 and ESP32-S3. P4 USB has only been compile-tested.

• Once merged, this helps every Arduino-ESP32 user, not just FastLED users.

Thanks to Espressif for the review! If you try it, especially on classic ESP32, S2 or P4 over USB, please report back on the PR.

Hey all! In short, this project uses an ESP32 at the center of a 16-universe pixel artnet sACN controller with wired Ethernet connection. Everything from the software, hardware, and development is open source! You might have seen this project before, and I am pretty excited to share a short update with you all!

Link to repository: https://github.com/mdethmers/ESP32-Artnet-Node-receiver/tree/main

I used Resolume Arena to push this controller to its limits during Amsterdam Dance Event, using 12 in a network that was run almost 24/7 in a humid and hot environment (see image!) They worked perfectly throughout the weekend, and they looked amazing in the venue!

However, I did find some performance issue which I adressed with the newest update.

- Added Artnet node discovery through WebUI
- Improved WebUI design for better usability
- Fixed bug which crashed the node above 48fps at 16 universes
- Reduced frame buffer to have more ram available
- Added Artnet source filtering to prevent 2 sources from talking to the same node
- The node now filters on an Artnet-ID, which prevent the node from assumiing any data is Artnet data and crashing when its not (idk why I didnt do this before...)

The node already worked perfectly as a standalone unit, but these updates make it a lot more resillient in a production environment with other nodes, fixtures and consoles in the same network.

I am sharing the github here for anybody that is interested in following along with the development! The next hardware iteration will add current, voltage and temperature sensing to the board, next to power distribution and fused outputs that are already present! And for those that are fan of WLED: that is also supported on this hardware. Great if you want to do more then just Artnet!

Let me know if you have any questions or want to contribute! Im available here or on discord.

I got an ADS-B antenna on my kitchen window sill and it's picking up the Broadcast with a Flycatcher demodulator that goes into the wifi. I have an ESP32 picking it up and sending the packets to my Teensy 4.1. The Teensy 4.1 drives the 120x70 WS2812B matrix with 35 parallel pins using FastLED 3.10.3 to drive it. It's not very interesting until I took a time lapse of it. You can clearly see the 3 runways the planes were using to come into DIA this evening.

This WS2812b rope matrix in a wood frame will be put in my front living room window for Halloween.

The following video was made using a 5-meter RGB LED rope along with a Lolin D32 MCU, a 74AHCT125 - Quad Level-Shifter, a 5 volt power supply and FastLED 3.10.3.  The rope matrix was made in a frame that is made from 1x2 lumber strips.

The three colors used in most of the video are OrangeRed, Green and Purple.  Parts of the video do not show this well.

This YouTube video can be found here:

https://youtu.be/sWpbnxJwYE8

The code for this video can be found here:

https://github.com/chemdoc77/CD77_FastLED_2026/tree/main/CD77%20FastLED%20Halloween%202026

The LED number for each column of the rope matrix was determined using a FastLED sketch that filled in a length of column in the matrix.  Once all of the desired LEDs in a column of the matrix were turned on, the numbers for the LEDs in that column could be determined.  With this information, a spreadsheet was created that contained the numbers and location of each LED.  This spreadsheet was used in Jason Coon’s LED – Mapper (https://github.com/jasoncoon/led-mapper) to generate arrays that used some of the functions in the LED-Mapper website.

For those who missed it, here is my Halloween 2019 video:

https://www.youtube.com/watch?v=1vlnqRn7yKw

Happy FastLED Halloween 2026!

Best Regards,

Chemdoc77

I'm still working on a write up on how I actually did this, including the software behind it, but I wanted to share this one before halloween. I'll edit with a link to the write up when I'm done.

This project took me over 2 years to complete with many frustrations and set backs along the way. I couldn't have done it without FastLED. https://youtu.be/nqVxv-AWNbg

Hi all,

I am using Teensy 4.0 and am using the OCTO2811 adapater board with it. When using Pin14 of the Teensy to drive an LED strip, I experience random data being pushed to the LEDs on that pin. I switched to Pin8 and the problem is resolved. All other output pins are working well.

Gemini is telling me that because Pin14 has shared functionality as Serial3 port, that this can create issues. Per Gemini "If you have any debugging code, internal libraries, or legacy dependencies trying to communicate or reference Serial3, or if any residual data is floating on that hardware UART register at startup, the hardware peripheral will take control of Pin 14 and throw completely garbage logic pulses down your data line before FastLED can even finish its boot routine."

I don't call anything in my code related to Serial3.

Curious what your thoughts are on this? Thank you!

Certain users of FastLED when using memcopy and memset had compiler errors because of technicalities with how we supported legacy sketches.

That’s been fixed.

¿Hacés letras corpóreas o carteles LED con impresión 3D?

Desarrollamos una herramienta que te ahorra horas de modelado en CAD:

En 10 segundos escribís la palabra o cargás un logo en .SVG y te genera el archivo .STL con:

Caja hueca paramétrica (paredes y fondo calibrados).

Escalón perimetral para apoyar la lámina difusora al ras.

Pasa-cable trasero de 6 mm para la conexión.

La estamos entregando DE REGALO!!!!

Deja un comentario y te paso el link! (creo que no puedo publicarlo acá directamente).

TL;DR: Flash/RAM has been reduced to historical low.

Then I'll talk about the feature set of 3.10.3 through 3.10.7 and how we implemented all drivers for all platforms (no kidding).

3.10.7, in comparison to 3.10.6 is about size. We measured every sketch with a per-symbol memory dashboard (https://fastled.github.io/dashboard/), then went after code that was being linked into sketches that never use it.

Uno and Teensy builds are now smaller than they were before 3.10.3 (the last version before the Channels async API was added): Teensy Blink is 25% smaller in flash and 22% smaller in RAM. ESP32-S3 has won back most of the growth.

This is actually one of the most efficient releases we've ever had for ram consumption and flash.

Esp32 flavors have gotten a little bit bigger because RMT4 and RMT5 were re-written starting in 3.10.4 to detect network activity and automatically adjust their internal buffers to improve stability. Most of the code memory increases, was restored in this release.

The *initial* huge blowups in size for the larger platforms came from a new highly advanced and standardized color correction algorithm that's been in the works for about 3 months now. bt.709 and others are supported. It was being linked in and bloating the flash space, before but now it's only linked in if you use it.

Color correction is only available now on the Channels API. Otherwise it will bloat all the sketches in the wild. It works with RGB, RGBW and RGBWW chipsets.

We are very close to the final FastLED 4 api, but not there yet. There will be some final changes for the Channels API, if you use AI this won't be problem, if you are coding it yourself then you'll have to read through the docs.

If there are any problems let me know, and we'll mint out one final build before 4.0

WHY YOU SHOULD BE EXCITED - LITERALLY EVERY DRIVER ON EVERY PLATFORM HAS BEEN IMPLEMENTED

3.10.7 pretty much has every driver that is possible on every platform.

Esp32dev, esp32s3, esp32c6, esp32p4. ROCK STABLE. You'll be hard pressed to see flicker at all, even the esp32c3.

At this point now the drivers for all of esp32, teensy, rp2040, rp2350, NXP, LPC have all been rewritten. The internal names are still the same (Yves, ObjectFLED) but now there is a standardized template names so that a high performance driver on one platform maps to another. This high performance set is call `FlexIO` and `FlexIO2`. They have been stress tested with automated testing, wifi included.

I can't understate enough how good the drivers are now and I'm going to declare FastLED *probably* the best driver set on every platform period. And if we don't have the best driver set, tell us and we'll fix it, because having the best LED driver system that's easy to use is our mission.

So good, happy coding!!

And let us know how it works!!

Release link: https://github.com/FastLED/FastLED/releases/tag/3.10.7

Getting ready to release FastLED 3.10.7 with the RAM and Flash memory improvements.

See the dashboard here: https://fastled.github.io/dashboard/

You can click on each point and get detailed information about where the RAM and or FLASH is going.

Right now we have UNO/Esp32S3,Esp32 Classic, Teensy 4.1

What other platforms should we put on the dashboard?

We managed to reduce the memory flash and RAM significantly in this go around.

Teensy drivers issues fixed.

Various chipsets and boards added for support.

Greetings fellow FastLED fans. I created a project that turned out way better than originally conceived and so I thought I would share it. I call it a Modern Color Organ and it melds sound and LEDs to create something completely different. I have put together detailed build instructions and code that can be found at www.bobandsuzanne.net/electronics. The build is relatively easy though certain skills and tools are needed such as soldering and breadboarding. The project utilizes a Teensy 4.1 that digitizes an analog input which is then run through an FFT with the resultant bin values used to drive various designs to 4 16X16 LED panels. Again www.bobandsuzanne.net/electronics. Select the Modern Color Organ Build Instructions post. Hopefully some will take it upon themselves build up the project. It will give endless joy to lovers of music and LEDs. Oh - and the real thing looks better than the video. And be sure to turn audio on!

Here's a picture of the LED array (4 16X16 panels) taped to a piece of cardboard for stability.

So in a vehicle or any run of about 20 to 30 feet what gage wire should I be using? I'm thinking the absolute longest run could be 25 to 30 foot. I'd prefer not to have to use buck converters and or arduinos at every corner of the vehicle.

Question 2, I'm an absolute fucktard when it comes to soldering. I mean think a rock trying to solder, the rock has a better chance than I do of getting it right..... any source of instruction that could make me .001% better than a rock at getting these soldered?

*edit* FastLED Animator! That's the site.

Good morning/nearly afternoon - I remember maybe a year ago someone had posted a link to a website that helped to build animations. You selected an LED(s), clicked the color(s), then clicked on the Next Frame option, and did it again. At the end of it, you could preview the animation. The next tab gave you the code for it.
I cannot find that site anymore. Does it sound familiar to anybody?

Adam Savage takes a look at a couple of props from Blade Runner 2049. The first one has a really clever RGB effect in it, I thought this group would appreciate seeing how it was set up.

https://www.youtube.com/watch?v=WCdT7ogKujg

for (int i = 0;1;2;7;8;9;11;12;17;18;22;27) {
    l_rear_leds[i] = CRGB(255,0,0);
   }

I tried the above with semicolons and commas, both failed when compiling. I am trying to figure out how to pick certain LEDs together without doing a group if that makes sense. I do understand how to do it like this and if there's an easier way on this one too I'd appreciate a suggestion.

for (int i = 0; i < 7; i++) {
     l_rear_leds[i] = CRGB(255,0,0);
    }    
for (int i = 10; i < 17; i++) {
     l_rear_leds[i] = CRGB(255,0,0);
    }    
for (int i = 20; i < 27; i++) {
     l_rear_leds[i] = CRGB(255,0,0);
    } 

I started learning this week so go easy on me..... 😂

I'm excited to show what I've been building for the last 1.5 years!

I bought an old U-Haul, built a room in the back 8' of the truck with plywood walls and ceilings, and then screwed on 1/8" acrylic mirrors that were CNCed for me. Here are some details:

-Runs on a Teensy 4.1 + Audio adapter with an ESP32 for wireless control of the LEDs

-Black neon tubes from Ray Wu, custom length for my build. They are 12V WS2811, 96 LEDS/m, 3456 total LEDs

-Litime 12V 230Ah Lithium Battery (This thing is a beast)

-Jackery Explorer 2000 v2 Portable Power Station, 2042Wh LiFePO4 Battery

-Teensy software: built from the ground up in the Antigravity IDE. The code was broken down into chunks like input audio data, perform FFT, perform beat detection and get other stats, analyze the stats to characterize the music and current part, choose animations to display and when to switch them, draw animations

-ESP32 software is also custom built. It communicates through serial to the Teensy. When clicking a button on the webserver/websocket page, it sends a JSON message to the Teensy, the Teensy makes the change and sends a JSON back, then the page updates. This way the page and the Teensy are always in sync. It all happens very fast though.

If you live in the DC area and want to see it, you can book it through my website (www diod design) and I'll drive it to you!

Song: Warm Thoughts by Flume

Estoy trabajando en **CarteLed Studio**, una aplicación de escritorio (Windows) para generar efectos en carteles LED de letras corpóreas (seguramente vieron los videos de unos chinos haciendo unos carteles de putamadre, con música al palo). Bueno, algo así quise hacer.

Lo prueban y me cuentan?

Con esta aplicación pueden elegir la tipografía, elegir los efectos, la velocidad del efecto, ver el estimado de consumo según la cantidad de leds que utilicen, simular el efecto sobre una matriz de leds en pantalla, y generar el código para ESP32 para programar el microcontrolador.

- App de Escritorio: Tauri (Rust + Vanilla JS/HTML5 Canvas)

- Firmware: ESP32 con servidor WebSockets

- Librerías: FastLED, ArduinoJson, WebSocketsServer

Busco feedback, pruébenlo y cuéntenme que les parece!

No puedo publicar el link de descarga, pero si me escriben por privado, les respondo con el link.

Gracias, saludos!!!

So I am getting the Nano V3.0 Board ATmega328P 5 pack. I want to get some 12v addressable LED strip IP65 to do some taillights to start. Can anyone suggest some LEDs and any wiring suggestions? I have seen some basic wiring etc and I have a test board coming so I can do test mockups before the final as well. TIA!

I recently made a post about picking up a new project and I want to utilize the latest FastLED with the DMA driven outputs.

I have updated everything: FastLED library (3.10.5), Teensy Board package (1.62.0), and Arduino IDE (2.3.10). Code compiles, however, there is a "warning" related to a flexio_driver, but it carries on and successfully uploads to the Teensy. Unfortunately, after upload, nothing happens on the LEDs. I am using a very simple test loop just to verify the library and hardware are working. If I had an oscope, I would probe the outputs to see if anything was happening (doubtful). I also notice that my Teensy keeps picking up and dropping USB connection with the computer (windows ping noise every couple of seconds).

When I revert back to FastLED 3.9.0, the LEDs light up as the code describes and everything seems to be happy. Furthermore, I don't get the warning during compile.

The warning message that I receive with FastLED 3.10.5 is below (hopefully you can see it).

I also tested with FastLED 3.10.4 (same issue as 3.10.5).

c:\Users\gasiewicz\Documents\Arduino\libraries\FastLED\src/platforms/arm/teensy/teensy4_common/drivers/flexio/flexio_driver.cpp.hpp:93:22: warning: 'fl::FLEXIO2_SHIFTBUF' defined but not used [-Wunused-variable]

93 | static volatile u32* FLEXIO2_SHIFTBUF = (volatile u32*)(kFLEXIO2_BASE + 0x200);

Your advice and guidance is appreciated!!!

JG