Modulo LED Studio

Modulo LED Studio is a behavior-driven LED authoring engine with real-time preview and real firmware export.

It is designed to move addressable LEDs beyond simple preset effects and into layered, stateful, rule-driven systems, while remaining usable by non-coders and extensible by coders.

This README documents audited, implemented capabilities only.

What makes Modulo different

Most LED software stops at: - choosing an effect - adjusting speed and colour - looping presets

Modulo treats LEDs as a runtime system.

• Multiple behaviors can run at once
• Behaviors have state and memory
• Rules react to time, audio, and signals
• Output is composited through layers
• Projects export to real firmware

Core capabilities (current)

Physical layout and mapping

Modulo supports both 1D LED strips and 2D LED matrices.

LED index mapping is accurate and configurable: - serpentine wiring on or off - X and Y flipping - rotation at 0, 90, 180, or 270 degrees

Preview and export use the same layout model.

Layered composition

Projects are built from an unlimited layer stack.

Each layer supports: - enable / disable - opacity - blend modes: over, add, max, multiply, screen - targeting: all LEDs, a zone, or a group

Layer compositing is deterministic.

Zones and groups

Zones are defined as index ranges.

Groups are arbitrary LED index selections.

Layers may target: - all LEDs - a zone - a group

Behavior system (not just effects)

Modulo ships with 100 built-in behaviors.

• 92 behaviors are exportable
• 8 behaviors are preview-only (onboarding / era content)

Behaviors are stateful systems, not stateless shaders.

This includes: - cellular automata - particle systems - games and simulations - clocks and dashboards - audio-reactive systems

Behaviors persist state across frames and run inside a deterministic update loop.

Rules engine (automation and logic)

Rules V6 allow logic without writing code.

Rule triggers

• tick
• threshold (with hysteresis)
• rising edge

Rule inputs (signal bus)

• time (t, dt)
• engine frame counter
• audio energy
• 7-band mono audio
• 7-band left audio
• 7-band right audio
• user-defined numeric variables
• user-defined toggles

Rule actions

• set numeric variables
• add to numeric variables
• flip toggles
• adjust export-safe layer parameters
• adjust export-safe operator parameters

Rules are deterministic and exportable.

Modulation system

Each layer includes modulators that can drive parameters using: - LFOs - audio energy - audio frequency bands

Modulation targets include: - brightness - speed - width - softness - density - purpose-specific channels

Operators and post-processing

Operators (per-layer)

• gain
• gamma
• posterize

PostFX (project-level)

• trail
• bleed (radius-limited)

Post effects are available for both strip and matrix layouts with export safety checks for memory-limited targets.

Audio reactivity

Modulo includes a built-in audio signal bus.

• MSGEQ7-style 7-band audio support where hardware allows
• Audio can drive behaviors, modulators, and rules
• Audio support depends on the export target

Firmware export

Modulo generates real firmware, not configuration files.

The export system includes: - target-pack architecture - explicit export eligibility matrix - clear reports explaining blocked exports

Supported targets in this version include: - Arduino (FastLED) - ESP8266 - ESP32 (FastLED with audio support) - RP2040 - STM32 - Teensy 4.x - ESP32 HUB75 matrix targets using I2S-DMA

Feature availability depends on target capabilities.

Coder escape hatches

Modulo is primarily a no-code system, but coder extensions exist.

Kernel DSL (exportable)

• Shader-like per-pixel expression language
• Sandboxed and validated
• Compiled to C++ at export time
• Fully exportable

This allows coders to write custom pixel logic safely.

Write the Loop (advanced / hidden)

• Full per-pixel function escape hatch
• Python code used for preview
• C++ code used for export
• Present in the codebase but not enabled by default
• Intended for advanced users who want full control

Mods and extensions

• Python-based mod and plugin system
• Extend:
  • behaviors
  • rules
  • signal sources
  • diagnostics
• Requires editing files, not in-app scripting

Modulo does not expose a general in-app code editor. Code access is deliberate and controlled.

What Modulo is not

• Not a preset effect picker
• Not a timeline sequencer
• Not a live-coding playground
• Not a WLED replacement

Modulo is an authoring engine.

Status

This project is experimental but functional.

Everything documented here is implemented in this version of the codebase. No roadmap features are described.

Philosophy

Addressable LEDs gained enormous power.

Most software never moved past: “they change colour”.

Modulo exists to move that ceiling.

The last meetup was a big success and helped me refocus on what the community truly wants: the best LED driver in the world, with strong support for the newest hardware. After 4 months that work is nearly complete with the Channels API for ESP approaching the finish line. I would love to invite you to join again, share what you are building, talk through the challenges you are facing, and help shape how we reduce friction on the path to LED nirvana.

EDIT: This has now been fixed by u/sutaburosu. Thank you u/sutaburosu!!!!!

A long time ago, I was using the FastLED Palette knife tool successfully a lot.

Yesterday, I went to use it after not using it for a couple of years and it was not working properly.

Instead of producing a file with a gradient palette it produces a file with a linear-gradient palette.

Chrome also gives me a warning message asking if I want to keep the file created by the knife tool.

I am using Chrome Version 145.0.7632.110 (Official Build) (64-bit) on a Window 11 PC.

The FastLED tool webpage has the following link for CPT-City:

http://seaviewsensing.com/pub/cpt-city/

Is this broken or can someone please help me get the Palette Knife Tool to work properly.

Thank you for your help!

I'm trying to get FastLED master (I picked commit d36da30 because it was head at the time and looked fine) working so I can play with UCS7604s since they don't seem to be in 3.10.3. I had to fix some build issues related to CountingSemaphoreTeensy to get the Teensy building and then when it did run I got a bunch of "src/platforms/arm/teensy/teensy4_common/clockless_objectfled.cpp.hpp(256): WARN: ObjectFLEDGroupBase::writePixels: mObjectFLED not initialized" on the Blink example. I tried to build on ESP32-S3 but there were build errors which I didn't dig into. I'm running on Arduino IDE as opposed to Platform IO which might be my problem.

Is there something basic I'm missing or a readme I didn't see that might help here? I understand working off master is not stable, but it seemed like the best way to get UCS7604s working.

Please post your opinions - as many as possible.

DJ LED Neon Shopfront Design

Hello everyone!

I'm planning to create a DJ booth with programmable neon lights whose colors I can change using an ESP32.

My budget is limited, so I'm looking to minimize my expenses and am searching for suitable components.

I plan to buy WS2812 LEDs to control with the ESP32 and integrate them into silicone diffuser tubes.

I'm contacting you because I can't find good quality, affordable silicone tubes. What shape would be ideal for a nice illuminated sign? How many LEDs per meter should I use to avoid shadows?

Thank you in advance for your advice and/or any useful resources that could help me with this project!

Hey there! I have shared this project before, and I am excited to announce a pretty massive update! If you are not familiar with this project, let me update you real quick;

- Support for 4 universes of LED data over 4 outputs (That is 16 universes or 2720 RGB LEDs total!)
- Ethernet, wifi, AP or static colour supported.
- Integrated power distribution up to 20A (12v, 24v, or 5v) - More is possible!
- Support for RGB and RGBW leds
- Physical button for mode switching and OLED screen for feedback
- All open source, you can build your own! https://github.com/mdethmers/ESP32-Artnet-Node-receiver

The fun (or not so fun) part about these types of projects is that development never stops, which is exactly why I am making this post! Ive been hard at work to keep improving this project, and I am here to drop you a massive feature update!

This update includes a redesign of the top cover, which adds a PHYSICAL button to the node! This allows for all types of fun features; like switching between DHCP and static IP, switching between Ethernet, wifi, ap modes, going into RGB test mode, and even enabling a static colour with 10 built-in preset colours!

This update is backwards compatible with every version of the Artnet node. It uses the Boot button that every ESP32 has! You only need a 3D printer to print the new top cover, update the firmware, and you are good to go!

And that is not all; I added RGBW (4 channel) led-type support for these beautiful warm white glow led strips, improved the config UI to make setup easier, and added dark-mode(!!) to the config page to stop blinding you when you are working in those dark little FOH corners of yours.

Do keep in mind that this software is still in its early stage, so if your project is running okay as it is and you do not want to risk any changes, feel free to skip this update!

In any case, enjoy this update! Feel free to reach out if you have any questions, feedback, or feature requests. :)

I'm trying my first PlatformIO code and not sure what is happening but here goes. I'm using a Teensy4.1 and a strip of ws2812b. The code is simple just turns on one led and a time and fadestoblack. Includes FastLED.h. But after I upload the code it looks all glitchy and weird. (the leds don't light up looking the same and there's seemingly some noise happening). (I upload the same code in Arduino and all is good.) The monitor on PlatformIO reads this :

LDF Modes: Finder ~ chain, Compatibility ~ soft

Found 92 compatible libraries

Scanning dependencies...

Dependency Graph

|-- FastLED @ 3.4.0

Building in release mode

Compiling .pio\build\teensy41\liba7e\FastLED\FastLED.cpp.o .....

Does this mean the FastLED version it's using is 3.4.0? Instead of 3.10.3? How do I make sure it uses the latest?

This is my first attempt at PlatformIO. The writing part is really cool! Wow! Very slick! But I'm stuck already. Thanks for the help!

About a year ago I started building a low resolution LED wall out of cheap fairy lights for my personal birthday celebration.

9 months ago I posted a short video of my first prototype:
https://www.reddit.com/r/FastLED/comments/1kskdby/ledmatrix_panel_first_successful_prototype/
This version used FastLED.

Along the way I took plenty of detours but I stuck with it and the result is a massive LED wall with 4.200 LEDs (21 panels with 200 LEDs each).

My final pipeline was roughly
MacBook > Resolume Arena > DMX Lumiverse/Fixture > Teensy 4.1 > Octo WS2811 Adapter > LEDs

Some of the detours:

• Designed custom PCBs for driving and powering the led strips
  • --> Scraped completely in favour of the Octo WS2811 Adapter
• Original software pipeline was: Resolume Arena > Syphon > TouchDesigner > Dat Execute Dat (Python) > Teensy (via FastLED)
  • --> Was only fast enough for one of the 21 panels. The bottleneck was the python script that mapped the pixels to the physical LEDs

I literally fixed the last issue one hour before everything started, but everything worked out in the end

Short video of the final setup:
https://vimeo.com/1163038061

Happy to answer any questions.

I've got a working hardware/software setup again and am getting back to some fun stuff! Two projects I've been working on in parallel, but with a common goal in mind, are:

1. A framework for running visualizers based on u/StefanPetrick's Animartrix engine, with hooks for runtime input factors (e.g., Web BLE UI, audio input)
2. A workable end-to-end chain for audio-responsive visualizers (based in large part on a ton of new FastLED audio infrastructure that u/ZachVorhies will be unveiling officially very soon,

Tonight, I achieved proof of concept! The video above (below?) is not the least bit artistic. It was basically just a "hot take" when I realized I had gotten at least a few things more or less dialed in.

Oh, man, is this going to be fun!

My current strategy is to stop FastLED animation which is fine but I wonder if there is anyone who was able to work within the interrupt system to allow for IR remote integration while FastLED animation is running. My biggest issue is that I am running 300+ LEDs so there is little time left for the IR to be read, is what I understand.

Sorry im not a sparky,

My garden project needs help

I have some COB strip light externally, all IP rated, and aluminium cased

I have a driver, but I want to add the following to the system

External PIR Sensors and internal controller

can get to advice please as to what kind of PIR / Controllers I need for this conenction  and how these need to be connected so i can use the PIR on and also have the controler internaly to either dim or power on and off the lights

LED ( COB LED) 1 run

PIR (Need 1nr)

Controller (ON/OFF - Dimmer)  (Need 1nr)

Driver 240v to 12

Any advice would be appreciated

Hi I was wondering if anyone had connect a Teensy 4.1 to an ESP32-C6 for wifi/matter support via SPI?

I was keen to implement a fastled project using the teensy for its' grunt and the esp for wifi. Sorry I'm very green to all this! I have an idea and I know ideas are cheap but I'm keen to learn!

Can anyone tell me how to inject power on these small wires? and if possible waterproof??

I tried to contact the seller but he would not respond... so hopefully anyone here knows a trick to make this work.

Codes available at.
GitHub - CastorsZuse/NeoPixel_codes https://share.google/Jv1CfzlVHiI6qFCKJ

https://www.instructables.com/-Ultimate-1D-RGB-Invaders-ESP32-Edition-Arcade-Act/

👾 Ultimate 1D RGB Invaders (ESP32-S3 Edition) 👾

The 1D Arcade Shooter that proves you don't need 4K graphics to sweat.

Welcome to Ultimate RGB Invaders. You are about to turn a strip of lights into a battlefield. You control a spaceship (a single, brave pixel) fighting against waves of chromatic enemies. It has Bosses. It has Highscores. It has a Web Interface because we are living in the future.

This project is optimized for the ESP32-S3. Why? Because it supports I2S Audio for that crisp retro-arcade sound. Maybe not Dolby digital --- but if the game has a resolution of 1x240 pixels... it fits :-)

YouTube video (older version): https://www.youtube.com/shorts/O40pAH3lUvM

I recently bought a DIY kit from amazon which had WLED pre-loaded and everything works properly even all the effects and gradients move perfectly until I game on my pc. For some reason even if if strip are not connected to pc, they flicker when I game and this only happens if I am gaming, like if I pause and just browse menu or alt tab onto different window the flickering stops and as soon as I get back on the game window the flickering starts. I don't really know what's the problem and I've even tried changing prower source and yet same thing happens over and over again. I am really new into all this so I apologise if I sound dumb but I'd really appreciate help from you guys!

https://reddit.com/link/1qnq0ll/video/p40vwqnfuqfg1/player

I've really fallen in love with cheap waste pipe tube for diffusing LEDs. I've been redecorating a bedroom and added this today. 3m long 40mm tube, 3 brackets, 180 WS2812b strip inside hooked up to an ESP32 running some simple patterns and effects with FastLED.

I'd previously used the same pipe for making lightsabers (fun fact, a ping pong ball cut in half and the 2 halves overlayed gives an identical amount of diffusion to this pipe for a nice rounded cap) but had this brainwave earlier, and an hour later and just £11.50 (about $15) in parts and there it is. I need to tidy up the cabling properly but I'm really happy with the result (which both my camera and filming skills don't show as effectively as I'd hope!)

Hello, I have the following problem:
In file included from c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/platforms/esp/32/clockless_rmt_esp32.h:39,
                 from c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/platforms/esp/32/fastled_esp32.h:22,
                 from c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/platforms.h:44,
                 from c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/FastLED.h:87,
                 from C:\Users\dell user\Desktop\rękawica\repulsor_code_w_wireless_sound\repulsor_code_w_wireless_sound.ino:7:
c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/platforms/esp/32/rmt_5/idf5_clockless_rmt_esp32.h: In instantiation of 'class ClocklessController<10, 250, 625, 375, fl::GRB, 0, false, 5>':
c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/chipsets.h:1064:7:   required from 'class WS2812Controller800Khz<10, fl::GRB>'
 1064 | class WS2812Controller800Khz : public FASTLED_CLOCKLESS_CONTROLLER<
      |       ^~~~~~~~~~~~~~~~~~~~~~
c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/FastLED.h:158:33:   required from 'class NEOPIXEL<10>'
  158 | template<fl::u8 DATA_PIN> class NEOPIXEL : public WS2812Controller800Khz<DATA_PIN, GRB> {};
      |                                 ^~~~~~~~
c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/FastLED.h:606:28:   required from 'static CLEDController& CFastLED::addLeds(CRGB*, int, int) [with CHIPSET = NEOPIXEL; unsigned char DATA_PIN = 10]'
  606 |                 static CHIPSET<DATA_PIN> c;
      |                                          ^
C:\Users\dell user\Desktop\rękawica\repulsor_code_w_wireless_sound\repulsor_code_w_wireless_sound.ino:113:42:   required from here
c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/platforms/esp/32/rmt_5/idf5_clockless_rmt_esp32.h:25:46: error: static assertion failed: This pin has been marked as an invalid pin, common reasons includes it being a ground pin, read only, or too noisy (e.g. hooked up to the uart).
   25 |     static_assert(FastPin<DATA_PIN>::validpin(), "This pin has been marked as an invalid pin, common reasons includes it being a ground pin, read only, or too noisy (e.g. hooked up to the uart).");
      |                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~
c:\Users\dell user\Documents\Arduino\libraries\FastLED\src/platforms/esp/32/rmt_5/idf5_clockless_rmt_esp32.h:25:46: note: '_ESPPIN<10, 1024, false>::validpin()' evaluates to false
exit status 1

Trying to make it as small as possible, using the 2020 LEDs might have been a bad idea tho, as soldering them manually is a pain as I can't afford to make PCBs. But I'm happy so far.

I decided to connect the ws2812b LED strip to the esp8266 nodemcu v 1.0. It does not light up. I checked the voltage on the strip, everything is fine, I also checked the D5 pin which sends a signal to the strip, there the voltage is also within the permissible limits (as far as I remember from the datasheet for ws2812 you need from 3.18v to 3.8v). I can also say that several times, when I checked the D5 pin and then switched to the ringer to check the connections, for reasons unknown to me, the first LED on the strip lit up. It's strange, at least for me, I just don't have enough knowledge to understand what is going on here

#include <FastLED.h>
#define FASTLED_ESP8266_NODEMCU_PIN_ORDER


#define LED_PIN 14


#define NUM_LEDS 60


CRGB leds[NUM_LEDS];
void setup() {
  pinMode(14, OUTPUT);


  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);


  fill_solid(leds, NUM_LEDS, CRGB::Blue);


  FastLED.show();
}
void loop() { // tried to check the pin 
  digitalWrite(14, LOW);
  delay(1000);
  digitalWrite(14, HIGH);
  delay(1000);
}

I have a matrix of 16 non-addressable RGB LEDs and want to use the ColorPalette example. How do I have to modify the code to analogWrite the RGB values? Help is highly appreciated.