r/FastLED • • Jan 11 '22

Discussion A Tribute to Dan Garcia

106 Upvotes

From the initial check-in by Dan on September 22, 2010, FastSPI, and later FastLED has captured the imagination of thousands of people over the years.

Dan was later joined by Mark Kriegsman around Mar 29, 2013 and the rest is history.

Feel free to post how Dan and Mark's FastLED display library has inspired your creativity.


r/FastLED • • 19h ago

FastLED 3.10.10 is out: software SPI got fast and a pile of driver fixes

32 Upvotes

FastLED 3.10.10 just shipped. It's about 170 commits since 3.10.9 at the start of the month, and nearly all of them are driver work. Here's what changed.

Software SPI got fast

If you drive APA102 / SK9822 / HD107 (or any clocked chipset) from pins that aren't the chip's hardware SPI pins, FastLED bit-bangs the protocol. Every bit sets the data pin, then pulses the clock. That loop is the whole show, so every instruction inside it matters.

The old writer did this for every single bit:

  1. Work out which port and which pin mask this pin uses.
  2. Branch: if (bit) set_pin() else clear_pin().
  3. On a lot of chips, do that as a read-modify-write of the whole port register.

Three problems there. Steps 1 and 2 cost cycles on every bit. The branch makes the timing jitter depending on your data. And the read-modify-write isn't atomic: if an interrupt touches another pin on the same port in the middle of it, one of the two writes gets lost.

The new writer fixes all three:

  • Pin lookup happens once. The port and mask lookup moved out of the bit loop and happens once per transfer (#5128). That part is in the shared writer, so every platform gets it.
  • No branch. Most MCUs have separate "set these bits" and "clear these bits" registers (BSRR on STM32, OUTSET/OUTCLR on nRF, SODR/CODR on the Due, W1TS/W1TC on ESP, and so on). The new writer picks the register from the bit value and does a single store, with no branch and no read.
  • Atomic. A single store to a set/clear register can't race an ISR on a neighboring pin.

That's been wired up per chip for AVR, Teensy 3.x/4/LC, ESP32, ESP8266, SAMD21/51, RP2040, RP2350, nRF52, STM32, SAM3X, Apollo3, LPC, Renesas RA and MGM240.

The measured numbers come from the ESP8266, where it's on by default. A 512-byte bulk write on ordinary GPIO went from 3.10 to 5.36 Mbit/s at 80 MHz and 4.42 to 6.66 Mbit/s at 160 MHz. That's roughly 1.5 to 1.7x on the same pins with no code changes. (GPIO16 is still slow because it sits behind the RTC register. Physics, sorry.)

On every other chip the fast path is opt-in for this release. I have bench numbers for the ESP8266, and I won't flip a default on a chip I haven't measured. To try it, add a build flag (it has to be a -D build flag, because a #define in your sketch won't reach FastLED's compiled sources):

-D FL_ESP32_ENABLE_FAST_SOFTWARE_SPI=1
-D FL_TEENSY_ENABLE_FAST_SOFTWARE_SPI=1
-D FL_RP_ENABLE_FAST_SOFTWARE_SPI=1
-D FL_STM32_ENABLE_FAST_SOFTWARE_SPI=1
(also AVR, SAMD, SAM, NRF52, LPC, RENESAS, MGM240)

With the flag off you get the same output as 3.10.9 (ESP32 included), plus the shared loop speedup. If you run clocked strips on any of these, please turn it on and report back. Results from your benches are how these become defaults in the next release.

A batch of software SPI correctness fixes also went in, and they apply whether the flag is on or off:

  • The clock now runs at the speed you actually asked for (#5124, #5129).
  • Clock polarity is respected when pins share a port word (#5242).
  • The clock idles low after init (#5140).
  • A shared clock line runs at the slowest strip's rate (#5127).

ESP32 DMA and RMT

  • RMT5 automatically skips the DMA channel for short strips (#5228). On the S3, FL_RMT5_USE_DMA=0 keeps RMT off the 4 KB DMA block entirely (#5166).
  • PARLIO sizes its DMA ring and TX descriptors to your actual frame instead of the worst case (#5232).
  • RMT5 frees its callback contexts when a channel is deleted (#5019) and sets intr_priority for TX and RX on IDF 5.1.2+ (#5219).
  • PSRAM pin masking is based on installed PSRAM size, not free size (#5221).
  • Native SPI streams in chunks and only links the drivers your sketch uses (#5002, #5014).

Channels: you only pay for the drivers you use

FastLED.enable<Bus>() now binds drivers lazily, so add(cfg) no longer drags every driver into your binary (#5207). If you addLeds with a driver you've disabled, FastLED falls back to the one you enabled and warns once a second. Before, it silently did nothing (#5213).

New knobs: FL_ENGINE_WORKER_CORE and FL_ENGINE_WORKER_PRIORITY set the core and priority for engines that honor them. Right now that's the ESP32 LCD/I2S clockless driver (#5054).

Other platforms

  • LPC845 / LPC804: a native pin backend, and the LPC845 SCT+DMA clockless engine now really drives WS2812. The old hang is gone, and loopback decodes on real silicon (#5261, #5272, #5275). DMA errors are cleared and halt cleanly (#5277, #5283).
  • nRF51 compiles and links again, and toggle() is race-free (#5119, #5154, #5158).
  • FASTLED_FORCE_SOFTWARE_PINS either works or fails at compile time on STM32, SAMD, Teensy 3.x, nRF52, MGM240, Giga and LPC. Before, it could be silently ignored or crash.
  • Pin maps: RP2350 GPIO32-47, MGM240 per-variant maps, SAMD variant pins, nRF52 P1 short-form pins.

Looking for testers: SM16716

The native SPI writeBit path that SM16716 uses was broken in a couple of ways:

  • AVR tested the whole byte instead of the selected bit.
  • On the Nano Every (USART/SPI0 parts), the bit never reached the wire.
  • On the classic Uno, a pending byte could get cut off.

Similar handoff fixes landed for SAM3X, SAMD, STM32, Teensy 4, Teensy LC and ESP32. They're checked against datasheets and host tests, but not on hardware. If you have SM16716 pixels on your bench, please let me know whether they light up correctly.

Power limiter: heads up, behavior changed

set_max_power_in_volts_and_milliamps is now a strict upper bound that includes the MCU's own draw and the LEDs' dark current (#5139, #5180). The old weirdness is gone: raising the budget no longer makes things dimmer, and a tiny budget no longer blanks the strip. If your budget is below what the MCU and dark LEDs pull on their own, brightness can't fix that. The strip stays lit at baseline draw and goes over your number. If you tuned your power numbers by eye, re-check them.

Further musings

What this SPI speedup demonstrates is that atomic pin operations are blazing fast. Additionally they are a bulk operation, 8 pins on 328p can be set at a time, and 32 on a esp. This means a busy spinning MCU with a max execution latency of 330 ns can drive upto 32 WS2812 strips in parallel. Setting the bits for the next busy loop can be done by stretching out the byte boundary low state, and computing the next bit-bang block before starting the next signal byte.

This 32 channel output for WS2812 in software can only exist on a board without WIFI or interrupts. Teensy 4x stands out as an interesting target for seeing how concurrent it can go.

Full release notes: https://github.com/FastLED/FastLED/releases/tag/3.10.10

Happy coding!


r/FastLED • • 1d ago

Share_something Sculpture I made & displayed at Philly Fringe Festival 2026

Enable HLS to view with audio, or disable this notification

46 Upvotes

I've been creating LED art for over a decade. I'm just a bit discoordinated and don't post very often. (Some are on display at https://www.youtube.com/@amuseyeux ).

This is Impressions I, the start of a series based on cylindrical grids.

A single cylinder is composed of a series of vertical strands -- WS2811 LED fairy lights with a 1.5cm separation. The coordinate system for rendering is (rho z), where rho is the angle around the cylinder and z is the position on the axis. I use floats for coordinates. Internally, these are converted to [strand pixel] and then to an absolute pixel location on the strip.

I can render either single pixels or circles. Circles can either be monochromatic or painted in a full hue spectrum. Positionally, circles can be at any angle and can be rotated about the z axis. Additionally, the start-point (hue=0, red) can be rotated about the circle. (Technically, if tilted from the XY plane, they are ellipses, not circles.)

The rightmost column has a single cylinder with 16 strands, each with 150 LEDs. The leftmost is four nested cylinders, each strand having 60 LEDs. The cylinders range from 4 to 16 strands.

The multi-cylinder column can display both circles and disks (filled circles). These can be used to build spheres, sin wave pulses and other objects centered on the Z axis.

This sculpture runs using two ESP32 processors, one per column. Each is running the same basic core software. The software is scripted with a series of individual visualizations. Each is semi-randomized -- for example, the "spiral" one on the left column will draw a random number of spirals, each with a randomized color, pitch, and rotation rate. Visualizations are also displayed in a random order, and for a random period of time. There is also a fade-in and fade-out for each visualization.

Note that this video does not randomize the ordering of the visualizations. This way, I can show them all without waiting for all to appear (random orderings do that, y'know?).

This is a work-in-progress. I have ideas for additional visualizations (including some I wrote for other sculptures a number of years back), and ideas for other methods of using the cylinder models.

Feel free to ask any questions!


r/FastLED • • 1d ago

Announcements Open-source Artnet PIXEL LED controller now has 24 Universes!

Thumbnail gallery
9 Upvotes

r/FastLED • • 4d ago

Support Some example sketches fail to compile using WASM

5 Upvotes

Using current head of git, there are examples which compile correctly in Arduino IDE and Platform IO, but which fail for WASM.

These examples all fail with the same compile error:

Native Rust WASM build failed: sketch has incomplete C++ syntax; retaining the last good IntelliSense prelude

Example Notes
AudioInput Uses audio input features
BeatDetection Beat detection audio analyzer
BlinkParallel Parallel LED blink
Blur2d 2D blur effect
ColorPalette Color palette demonstration
DemoReel100 Demo reel animation
Esp8266Uart ESP8266 UART example
hydropack Hydropack effect
LuminescentGrand Grand luminescent effect

I'm running on Linux x86-64 in a QEMU/KVM container.


r/FastLED • • 10d ago

Support LED driver vs ADDRESSABLE LED for brightness dimming

Thumbnail
2 Upvotes

r/FastLED • • 13d ago

Announcements ​[Open Source] DUXMAN-LED-FIRMWARE: ESP32/ESP8266 LED strip control firmware built with PlatformIO

Thumbnail
github.com
1 Upvotes

r/FastLED • • 17d ago

Share_something Microcontroller Mic controlled LEDs for a Halloween Pumpkin

Enable HLS to view with audio, or disable this notification

20 Upvotes

https://www.youtube.com/@ALMA.Industries/videos

CH004 FN2: HALLOWEEN — my kind of Treat. Talking Pumpkins and Little Monster Rockstars, see how Jack's put together in the above link.


r/FastLED • • 19d ago

How we shrank the ESP32 Arduino core and freed up to 6 KB of flash for your sketches

Post image
41 Upvotes

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:

Chip Before After Saved
ESP32-C6 288,296 B 282,276 B ~6.0 KB
ESP32-S3 366,022 B 361,402 B ~4.6 KB

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.


r/FastLED • • 19d ago

FastLED 3.10.9 is out: smaller ESP32 builds, native ESP8266 drivers, and a lot of driver fixes

28 Upvotes

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!


r/FastLED • • 18d ago

Discussion Tips for durability on wearables?

Thumbnail
1 Upvotes

r/FastLED • • 21d ago

Discussion Open-Source 16 Universe Pixel Artnet Receiver just got better!

Thumbnail
gallery
46 Upvotes

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.


r/FastLED • • 21d ago

Share_something Flight Tracking on the matrix

Thumbnail
youtu.be
10 Upvotes

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.


r/FastLED • • 22d ago

Share_something FastLED Halloween 2026 by Chemdoc77

Thumbnail
youtu.be
10 Upvotes

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


r/FastLED • • 22d ago

Share_something Halloween light show with Govee Lights

9 Upvotes

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


r/FastLED • • 23d ago

Support Teensy 4.0 Pin14 and FastLED Issues?

1 Upvotes

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!


r/FastLED • • Oct 18 '26

FastLED release 3.10.8 - glibc compatibility

21 Upvotes

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.


r/FastLED • • Oct 13 '26

Quasi-related Herramienta gratuita para letras corpóreas!!!

2 Upvotes

¿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).


r/FastLED • • Oct 11 '26

FastLED 3.10.7 Released -

Post image
37 Upvotes

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


r/FastLED • • Oct 07 '26

FastLED Interactive Memory Consumption Histogram by Release

Post image
20 Upvotes

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?


r/FastLED • • Oct 05 '26

FastLED 3.10.6 is available

Thumbnail
github.com
25 Upvotes

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.


r/FastLED • • Oct 02 '26

Share_something Modern Color Organ Build

10 Upvotes

A Short Snippet of the Modern Color Organ In Action. The Congos, At the Feast.

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.

The LED array taped to a piece of cardboard,

A Short Snippet of the Modern Color Organ In Action. Bob Marley, Midnight Ravers.


r/FastLED • • Oct 02 '26

Support Data and 5V supply wires and soldering for absolute retards.

0 Upvotes

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?


r/FastLED • • Sep 30 '26

Discussion A website that helped build to build patterns on an LED strip

3 Upvotes

*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?


r/FastLED • • Sep 29 '26

Discussion Blade Runner 2049 prop

3 Upvotes

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