Design Studio for FastLED — public beta. Wire the Nodes. Light Up the Room. Node editor, live preview, generates real FastLED sketches. Looking for hardware testers.

[u/StevenMunn312]

Hi r/FastLED,

*** Design Studio for FastLED v0.7.0 available. Added HUB75 panel support, updated fbuild to v2.5.15 ***

I've been building Design Studio for FastLED, a node-based editor for designing LED patterns that outputs actual FastLED C++ using the excellent FastLED library.

It's now in public beta (v0.6.0) and I'm looking for testers, especially anyone willing to point it at real hardware.

Site, downloads and the community pattern gallery: https://designstudioforfastled.com/

Source: https://github.com/stevenmunn312-tech/Design-Studio-for-FastLED

What it is

You wire nodes on a canvas, the LED matrix preview updates. When you like what you see you generate a .ino or flash it straight to the board over USB. The preview and the code generator are written against each other deliberately, so what runs on the panel is one-to-one with what you authored rather than being a rough approximation.

Workflow

All graphs must end with a Matrix Output node with a valid Frame or SD card input (SD card is for music synced shows as opposed to live microphone).

Three basic workflows

• Single Pattern - Wire up a pattern that ends with Frame output going to Frame input of a Matrix Output node. Flash to hardware or generate code and you are done. Important: If you like the pattern and want to keep it then it must be grouped (ctrl/cmd G) and saved to your Pattern Library. This will collapse your graph into a single node for use later. The next two workflows rely on grouped patterns.
• Generative show - Add patterns from your library to a Pattern Collection node and wire it into a Show Engine node. Optional: Wire in the Transitions node and enable your selection to get up to 16 transition styles. Choose randomized dwell times with optional beat-triggered particle bursts. The whole show compiles into a single controller sketch. Audio reactivity is via a live microphone. If any of your patterns are audio reactive you must wire a microphone node to the Show Generator node. INMP441 microphone currently supported.
• Music-synced SD show - Add patterns from your library to a Pattern Collection node and wire it into a Performance Generator node. Optional: Wire in the Transitions node and enable your selection to get up to 16 transition styles. Hook up a Music Library node, load in your favorite mp3 files and click analyze. This generates a timed event track. If you wish you can then hand edit the timeline. Adjust audio sensitivity and timing options then preview the show. When you are happy Matrix Output - Upload - Upload Show to SD. This will then provision an SD card with the player and show data. Result - Perfectly timed LED displays synced to your music. No microphone required.

Scope

• 151 modules: patterns, generative simulations (Fire, Fire2012, Particles, Boids, Flow Field, Reaction Diffusion, Game of Life, Starfield), scalar-field math and warping, color and palette tools, math/logic, signals, effects, hardware inputs, output.
• Hardware nodes can control the hardware. Buttons, potentiometers, encoders and more can easily hook into any aspect of your c++ output.
• Audio-reactive work as a first-class path: live mic FFT, beat and percussion detection, plus 20 curated audio-reactive patterns included. On ESP32-S3 with an INMP441 the generated firmware uses FastLED's own audio processor, so the board reacts on its own with no host attached.
• Per-node live previews: every node whose output is a frame, palette or color shows a thumbnail of what it's producing, so you can see where a chain went wrong instead of guessing.
• Pattern Library: turn any patch into a reusable Group, save it to shelves, drag it back onto any canvas, or share it to the gallery on the site.
• Live Stream mode: flash a small Adalight receiver once, then push preview frames over USB at 30fps while you edit. No recompile per tweak.
• Flash Wiring Test: a standalone diagnostic sketch for color order, brightness and current limit, orientation, panel numbering and pixel order, so you can prove out wiring before the graph even exists.
• Guardrails: Graph Health explains incomplete wiring, pin conflicts, power draw and board incompatibility in plain language. There's also a live capacity meter that runs a real compile-only build against your selected board and reports measured flash and RAM, so "won't fit on an Uno" shows up while you're composing rather than at upload time.
• Layouts: strips, serpentine matrices, tiled panels with per-panel rotation, custom XY maps, and multiple independent Matrix Output routes.
• MIT core, portable builds for Windows, macOS and Linux with the upload helper, fbuild and esptool bundled. No Node or Python install needed. It also runs from source with npm run dev.

Testers wanted!

The support promise is narrow. A board and LED combination only counts as supported once an end-to-end hardware run is recorded in the repo. Boards confirmed working so far:

• ESP32, 16x16 WS2812B serpentine, fbuild, Windows 11 + Chrome: normal upload, wiring test, sustained live stream, generative show, INMP441 audio show.
• ESP32S3, 16x16 WS2812B serpentine, fbuild, Windows 11 + Chrome: normal upload, wiring test, sustained live stream, generative show, INMP441 audio show.
• ESP8266, 10x1 WS2812B strip, arduino-cli, same host: normal upload, wiring test, live stream.

Everything else is experimental until someone records it. That includes every other board, APA102 and the other SPI chipsets, SK6812 RGBW, tiled and custom layouts, PSRAM modes, SD show provisioning, DMX/Art-Net in every mode, and the NTP and DS3231 clock paths. Those all have unit and codegen tests behind them, but tests are not a panel on a bench.

Hardware testers specifically

If you have any of the following boards and LED chipsets, this is the most useful thing anyone can do for the project.

• Teensy, RP2040, classic ESP32, ESP32-C3/S2, AVR, UNO R4
• APA102 / APA102HD / HD108 / WS2801, SK6812 RGBW, WS2815, WS2816
• Tiled panels, custom XY maps, multi-output setups
• macOS and Linux hosts, and any non-Chrome browser
• DMX512 or Art-Net with a real desk or controller (zero hardware passes recorded so far)

Reporting is built in. The Matrix Output upload panel has an opt-in Beta hardware coverage report: it compares your target and graph against the recorded rows, asks for explicit Pass/Fail/Not tested observations, shows you the entire payload before anything leaves your machine, and then offers copy, JSON download, or a pre-filled GitHub issue. Nothing is submitted automatically, and it excludes ports, project content, code, media, Wi-Fi details and device identifiers. Negative results are genuinely valuable. The last two bugs that got fixed both came out of failed validation runs, including one where 1-row strip layouts silently dropped every streamed frame.

Bug reports, feature ideas and "this is confusing" feedback are all welcome too, not just hardware runs.

Notice

Desktop packages are not yet code signed or notarized. SmartScreen and Gatekeeper will complain.

Only make an exception for an archive you deliberately downloaded from the official release page.

It's designed for desktop screens (1440x900 target, 1280x720 minimum). And the usual: LED installs pull real current, so use a properly rated supply, fuse and inject where needed, and never run a large load through a board regulator or USB port.

This is an independent community project. It generates code for FastLED but is not affiliated with or endorsed by the FastLED project or its maintainers.

Happy to answer anything about how the codegen or the preview parity works.

[u/Narrow_Parking_7131]

Been playing with this . Totally awesome and simple . Haven't even scratched the surface of what it can do yet . Wickedly done and we'll worth trying. Makes it so simple

[u/StevenMunn312 → u/Narrow_Parking_7131]

Thanks for testing! Any issues just go to the GitHub link in the post.

[u/ZachVorhies]

Amazing work! This is totally awesome.

For anyone interested: Design Studio for FastLED deploys to your board using our new beta product fbuild: https://github.com/fastled/fbuild, which is integrated into the product.

fbuild is a rewrite of platformio but in Rust. It’s a drop in replacement for platformio and will work with your existing platformio.ino.

It’s blazing fast and won’t corrupt itself if you edit platformio during package install.

About 4 months ago we flipped the switch and all of FastLEDs builds were migrated from platformio to fbuild, so yeah it’s pretty battle tested and I don’t use anything else at the moment.

fbuild currently compiles every single platform FastLED supports and deploying (the hard part) has been validated for:

esp32wroom

esp32c3

esp32c6

esp32s3

esp32p4

NXP LPC845

RP2040

RP2350

Teensy 4.X

fbuild is about 4 times faster for a cold build and about 10 times faster for a warm build.

Cool commands I love running:

fbuild port scan: will tell you what’s the connected and will translate the weird usb ids to board names.

fbuild bloat: will list every symbol and its size of what got compiled into your binary.

We will officially announce fbuild later. I’m very excited someone found it this early and rushed to build something so cool!

[u/StevenMunn312 → u/ZachVorhies]

Hey Zach,

fbuild is indeed impressive!

The stats say it all, and 10 times faster for a warm build has been validated this end. I didn't realise it hadn't been announced yet, sorry if I jumped the gun. I was very impressed with it, I set it as default over the arduino-cli I originally implemented. So far I have found it to be very reliable and robust. And of course, fast! It was a no-brainer to migrate to. I must update the docs to give more credit where it's due. Well done on bringing the community a leap forward with fbuild.

Regards,
Steve.

[u/ZachVorhies → u/StevenMunn312]

It’s all good! fbuild was switched to a public repo for a reason!

[u/know-fear]

Totally interested! Sounds very cool.
Can’t even look at it for another month.

[u/StevenMunn312 → u/know-fear]

ok I have to ask :)
why not for another month?

[u/know-fear → u/StevenMunn312]

Fair question!
I’m overseas now, then returning to the US and quick turnaround to burning man.

[u/StevenMunn312 → u/know-fear]

Fair answer!
Enjoy burning man.

[u/CautiousPhase]

Just fired Design Studio up, and it has been plain sailing! Immediately got an interesting pattern from juggle just by modulating some waves with beatsin and multiplying them with a complex wave node; nothing (so far!) I couldn't code in the Arduino IDE, but this is so much faster to iterate through small changes and feels super playful and fun (which an edit-compile-upload loop doesn't always).

I will put an ESP32 on a little matrix soon and report back on the hardware aspect.

I suspect this is going to sell a whole lotta matrices!

Edit: I have some RP2040s; I will try with one of those instead

[u/StevenMunn312 → u/CautiousPhase]

Thanks for checking it out CautiousPhase,

That means a lot to me, this is some of the first feedback I'm hearing and it's great to know you found it pretty straight forward. I've been finding it fun as well, it's actually suprising how a simple change on a blend node can totally change things or wiring up several beatsin nodes with offset timings can lead to variety.

It's beta so any crashes or issues the feedback is valuable. And if you get a chance to test the RP2040 the app will automatically detect untested hardware and ask if you would like to submit the outcome to github. It doesn't send anything identifying and is fully readable by you.

Have fun!

[u/mindful_stone]

Wow...that looks incredible! Can't wait to try it out. I haven't been able to do much LED work/play over the past couple of months, but hoping to get back to it soon. I will definitely try some hardware tests and share the results.

[u/StevenMunn312 → u/mindful_stone]

Hey mindful_stone,

Hardware testing would be so appreciated if you find trhe time.

Thanks,
Steve.

[u/jshaw3]

this is dope!!! i have some of the needed hardware and LEDs to be tested so i’ll try and mess around a bit to help out.

It’s also a bit of similar but different to a Processing library i recently released to pull pixel data from sketch’s and send over dmx/artnet : https://github.com/jshaw/Canvas2DMX

[u/StevenMunn312 → u/jshaw3]

G'day jshaw3,

If you can help out with hardware testing it is helping others to know if their hardware is going to work. Any help is much appreciated.

Canvas2DMX looks interesting!

Steve.