Drivers

A driver consumes the light output and sends it on: to LEDs on a wire, a HUB75 panel, the network, a smart-light bridge or the web UI.

Each reads its own slice of the Drivers container's buffer through the shared window controls. A physical output corrects it through the shared correction controls, while Preview shows it as it is. A card's emoji are its tags.

Hdmi 🖥️

Shows the layer on a monitor through the board's HDMI port, scaled to the screen. One light per pixel, placed where the layout puts it and corrected as the wall is, for a monitor, a projector or an LED wall's sending card (Novastar, ColorLight). ESP32-P4 boards with an LT8912B bridge, such as the Olimex ESP32-P4-PC; a Linux machine's HDMI port, such as a Raspberry Pi's, without a desktop; a Mac or Windows PC's second display.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• mode: The screen mode; 1280x720 suits a 1080p monitor, which scales it by exactly 1.5.
• scaling: Fit keeps the grid's shape with black bars, stretch fills the screen.
• fps: Frame-rate ceiling; the screen refreshes on its own.
• monitor: What the monitor says of itself in its EDID: name, preferred size, a mode it lacks.
• bridge: The bridge's synthesizer word against the one programmed, and the sync it measures.

Attribution: Espressif, Olimex

Source · Tests

Hls 🖥️

Streams the layer as H.264 over HLS from the device's own HTTP server, which a TV, VLC or a browser can play. Open the url the card shows. Where Ndi feeds production tools, this feeds anything that plays video. Each light a scale by scale block, placed where the layout puts it and corrected as the wall is. Latency is HLS's own, 2 to 5 seconds, so this is for watching rather than live control. The status line carries the state, the drops, or why the encoder stopped.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• targetFps: Encode-rate ceiling, and the bandwidth knob: bitrate follows.
• scale: Video pixels per light, 0 being auto; one factor for both axes.
• encoder: Which ffmpeg encoder to use; hardware ones offload the encode.
• url: The address to open in VLC or a browser, relative to this device.

Attribution: Delphium, HLS, FFmpeg

Source · Tests

Hub75

Drives HUB75 LED panels straight from the board's own pins, with no receiving card in between. The sibling of PanelCard, which drives the same panels over Ethernet. A MoonHub75 runs a 64x64 1/32-scan panel at 6-bit and 1,508 Hz; larger walls wait on reports.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• board: The board's wiring: picking one fills the fourteen pins, Custom keeps yours.
• peripheral: The silicon block that drives the panel, LCD_CAM or Parlio, where the chip has both.
• scanRate: The panel's scan rate: 1/8, 1/16 or 1/32, read off the panel.
• bitDepth: Bit planes per frame: color levels against refresh and memory.
• clockEdge: The edge the chips sample on; every pixel one column over means the other.
• refresh: The measured refresh rate: the number to report when a panel flickers.

Attribution: LostHope, Delphium, RobWomp, mrcodetastic, hzeller, ESPHome, Adafruit, Waveshare

Source

Hue

Drives Philips Hue bulbs as pixels: each color bulb in the driver's window becomes one pixel, pushed to the bridge over its HTTP API. The same shape as NetworkSend, over HTTP rather than UDP. One command goes to the bridge every half second, so it gives smooth ambient color, not strobing. Up to 32 bulbs, a LAN's worth, which bounds the driver's memory.

• start: The first light of the shared buffer this driver reads.
• count: How many lights it reads from start; 0 reads them all.
• bridgeIp: The bridge's LAN IP, entered in the UI (4 octets).
• appKey: The Hue app key, filled by pair; a password, so masked and kept out of documents.
• pair: Press it, then the bridge's link button within about 30 s to claim a key.
• room: All rooms, or the one whose lights are driven.
• light: Narrows the driven lights to one light of that room; 0 is All.

Attribution: Philips Hue

Source · Tests

Ndi 🖥️

Publishes the layer as an NDI video source that OBS, Resolume, TouchDesigner or any NDI receiver finds by name on the network. One light per pixel, placed where the layout puts it and corrected as the wall is. Where Preview draws the lights for a person, this hands the same frame to a production tool. Desktop only, as no NDI runtime exists for the ESP32 chips. A board reaches the same tools over Art-Net, sACN or DDP with NetworkSend, and takes them in with NetworkReceive.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• sourceName: The name a receiver lists; blank uses the device's own.
• fps: Frame-rate ceiling, declared in every frame.

Attribution: NDI, Delphium

Source · Tests

NetworkSend

Streams the buffer over UDP as Art-Net, E1.31 or DDP, its packets paced so receivers keep up, to Falcon and Advatek controllers, xLights and LedFx. One driver feeds many receivers, each a run of the window at its own address, as an LED driver fans out over pins.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• start: The first light of the shared buffer this driver reads.
• count: How many lights it reads from start; 0 reads them all.
• protocol: The wire protocol: Art-Net, E1.31 or DDP; the port follows.
• ddp_port: The UDP port DDP sends to: the ddp_port of the receiver it feeds.
• addressing: How packets travel: unicast, Art-Net broadcast or E1.31 multicast.
• hosts: Receiver addresses or names, in fan-out order; blank idles.
• lightsPerHost: Lights per receiver; blank splits evenly, one number to all, a list each.
• universe_start: The first universe, sent as is, except E1.31 sends a 0 as 1; DDP ignores it.
• channels_per_universe: Channels each Art-Net or E1.31 universe carries, exactly; DDP ignores it.
• fps: Frame-rate limit, so a fast render tick does not flood the LAN.
• packet_gap: Microseconds from the start of one packet to the next; 0 sends a burst.

Attribution: Art-Net, E1.31, DDP, troyhacks

Source

PanelCard

Streams the buffer to ColorLight 5A-75 receiving cards as raw Ethernet, taking the place of the sending card that normally feeds them. The board renders and sends, so it replaces a host PC driving the same wall. There are no geometry controls: the wall comes from the Layout, cut into card rows.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• start: The first light of the shared buffer this driver reads.
• count: How many lights it reads from start; 0 reads them all.
• format: The card's wire format.
• firmware: The card firmware; a wrong one and the wall barely updates.
• interface: The network adapter the frames go out on.
• fps: Frame-rate limit, so a fast render tick does not saturate the link.

Attribution: FPP, Harald Kubota, mplayer-colorlight

Source · Tests

ParallelLed

WS2812B-class LEDs on up to 16 strands clocked out at once by a DMA peripheral, which makes a large wall possible. Each strand takes the next run of lights on its own GPIO. Switching between peripherals is a control change, with no reflash. For a few strands see RmtLed, and for a Teensy 4.1 its hardware page.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• start: The first light of the shared buffer this driver reads.
• count: How many lights it reads from start; 0 reads them all.
• pins: Data GPIO list: 18,17,16 or ranges like 20-23. Empty idles.
• ledsPerPin: Lights per strand: blank splits evenly, a number, or a list.
• frameTime: What one frame costs on the wire: the pipeline's headroom.
• peripheral: The DMA peripheral that clocks the strands out, filtered to what the chip supports.
• doubleBuffer: Encode the next frame while this one clocks out, where supported.
• clockPin: The i80 write strobe (WR): the pixel clock, and the expander's shift clock.
• dcPin: The i80 bus's data/command select, which LCD-IDF mandates though WS2812 ignores it.
• pinExpander: A 74HCT595 per data pin: each pin then drives 8 strands.
• latchPin: The 74HCT595 latch (RCLK) pin, needed with the expander.
• shiftOverclock: Shift the '595 at 26.67 MHz, not 20, for short wires; off if a panel scrambles.
• useRing: Stream the frame as a ring of small internal buffers, or send it whole from one block.
• ringSnapshot: Copy each frame before the ring sends it, so a frame never mixes with the next.
• ringAuto: Size the ring by itself and show the numbers it picked in the controls below.
• ringRows: Lights per DMA buffer: the ring's grain, and the RAM against interrupt-rate lever.
• ringBufs: How many buffers the DMA circulates, each ringRows rows of internal RAM.
• ringPadUs: Inter-buffer zero-pad in µs, buying refill deadline at a linear frame-time cost.
• ringDbg: The ring's live counters, once a second; ab counts lost frames, 0 on a healthy ring.
• loopbackTest: TX to RX self-test: send a known pattern, bit-verify the capture.
• loopbackTxPin: TX pin override for the test; unset uses lane 0.
• loopbackRxPin: Jumper this to the TX pin: the self-test reads the pattern back here.
• loopbackStrand: Strand carrying the test pattern, expander mode only.
• loopbackIntrusive: ON rides the live pipeline, OFF rebuilds a private bus.

Attribution: hpwit, troyhacks, OctoWS2811, ObjectFLED

Source

Preview

Streams a true-shape 3D preview of the layer to the web UI. Only the real lights are sent, at their real positions, so a sphere, ring or arbitrary map shows in its true shape. It is the one boot-wired driver. It streams on its own WebSocket channel so a large frame never delays the control plane. It sends only while a viewer is watching, and moving heads show their beam.

• targetFps: The rate the preview aims for: lower for detail, raise for smoothness.

Source · Tests

PwmLight

Lights whose channels are each a pin, pulsed by the chip's PWM: a bulb, an analog RGB, RGBW or RGBCCT strip, a QuinLED An-Penta controller, on any ESP32's LEDC. The fixture profile names what each pin carries, so the light count is the pins divided by the profile's channels. One timer serves the driver and each pin takes one channel, up to 16 on the classic ESP32 and 6 on the C3. The channels' pulses start spread over the period, so full white never switches all at once.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• start: The first light of the shared buffer this driver reads.
• count: How many lights it reads from start; 0 reads them all.
• pins: One GPIO per output channel, in the fixture's channel order.
• bits: PWM resolution, which sets the pulse rate.
• frequency: The pulse rate the resolution gives, to read against a fixture's datasheet.

Source · Tests

RmtLed

Addressable WS2812B-class LEDs on a handful of strands, clocked by the chip's RMT peripheral. The classic choice, and the one that needs no DMA peripheral: for more than a few strands see ParallelLed. Flicker on LEDs that should be off is signal integrity rather than firmware, and the signal integrity playbook walks the checks.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• start: The first light of the shared buffer this driver reads.
• count: How many lights it reads from start; 0 reads them all.
• pins: Data GPIO list: 18,17,16 or ranges like 20-23. Empty idles.
• ledsPerPin: Lights per strand: blank splits evenly, a number, or a list.
• timing: Wire bit rate: a 12V WS2811 needs 400kHz, most LEDs the faster.
• t0hNs: Custom timing: how long a 0 bit stays high, in nanoseconds.
• t1hNs: Custom timing: how long a 1 bit stays high, in nanoseconds.
• periodNs: Custom timing: the whole bit cell, in nanoseconds.
• loopbackTest: TX to RX self-test: send a known pattern, verify the capture.
• loopbackTxPin: TX pin override for the test; unset uses the first data pin.
• loopbackRxPin: Jumper this to the TX pin: the test reads the pattern back here.
• loopbackFrame: Send whole frames back to back and verify every bit.

Attribution: hpwit, WLED, FastLED

Source

Rtsp 🖥️

Serves the layer as an H.264 stream a player pulls over RTSP, with a fraction of the delay HLS carries. RTSP sends each frame as the encoder produces it, which makes this the remote view to reach for. Each light a scale by scale block, placed where the layout puts it and corrected as the wall is. It runs on the ESP32-P4 and the desktop, and shares one encoder with Hls, so only one of the two runs at a time.

• localBrightness: This driver's dim, multiplied with the global brightness.
• curve: How brightness maps to output: CIE 1931, a gamma, or linear.
• fixture: The fixture profile applied per light, for channel order and white.
• whiteMode: How the white channel is derived, shown when the profile carries one.
• fixtureRef: The profile name an older config saved, read once and then emptied.
• targetFps: Frame-rate ceiling, which is also the keyframe interval.
• scale: Video pixels per light, 0 for auto; each light a solid block.
• url: The address to play in VLC or ffplay, with the device's own IP.

Attribution: Delphium, RTSP, RTP

Source

Hdmi, details

Connect the monitor

A monitor plugged in or woken later is picked up within a second. Set its input to HDMI, not automatic, which some monitors leave for another input. Noise after a cold start: reset the board.

Status line

It says	It means
no HDMI output on this board	No bus for the bridge, or no HDMI port it may open
output did not come up, retrying	No bridge answers, or a desktop holds it
no monitor connected	Plug one in: a second, on a computer
<w>x<h> on <mode>	Live; orange when the monitor lacks the size

Hls, details

ffmpeg

It runs on the desktop, where you install ffmpeg yourself and then open the stream (Watching the output).

On the ESP32-P4

There is no ffmpeg: the chip's H.264 block encodes. It takes even dimensions from 80x80 to 1920x2032; an odd wall has its scale doubled, a larger wall is refused.

Hub75, details

Which of the two paths

A receiving card (PanelCard) earns its place above roughly 16,384 pixels; below that this driver is the small end of the split. HUB75 panels has the choice.

Ndi, details

The NDI runtime

You install it yourself; without it the driver says so and nothing else changes. The steps: installing the NDI runtime.

Receivers

To see the output you need a receiver. NDI Video Monitor, part of NDI Tools, is the simplest; OBS gains an NDI Source through the DistroAV plugin. MoonLight appears under the name in sourceName, or the device's own name when that is blank.

Status line

It says	It means
NDI runtime not installed	Install it: Watch the output as video
could not create the NDI source	The runtime is there but refused, usually a name clash with another source
sending <w>x<h> at <n> fps	Live; look for it in your receiver

NetworkSend, details

Mixed fixtures

Mixed fixtures take a driver per fixture type, each with its own start, count and fixture, the richest motion fixture first.

driver	window	fixtures
A	start 0, count 2	the two big pan/tilt/zoom heads
B	start 2, count 4	four smaller pan/tilt heads
C	start 6, count 10	ten RGBW pars

PanelCard, details

Why 1 Gbit

The cards need 1000 Mbps for wire time, not bandwidth: they latch on the sync frame, so a whole frame must arrive inside the inter-frame window. At 100 Mbit expect tearing or wrong rows; the driver warns but still sends (Panel cards).

ParallelLed, details

Which peripheral

Start with i80. Choose MoonI80 for frames too big for memory or a pin expander, Parlio on a P4, GPIO-DMA on a Teensy 4.1. LED drivers has the chips, limits and wiring.

Preview, details

Close it when you do not need it

The device renders preview frames only while the preview pane is open. Dismissing the pane stops that work entirely, which frees the device and keeps the UI responsive on a large layout. Worth doing while you edit effects on a big wall.

It thins itself out

When the connection cannot carry full detail, the preview shows a regular sample of the lights and the status reads 2 watching · 1/4. Drop-free stretches earn detail back a step at a time. A slow effect drops nothing, so it never costs detail.

If the preview looks choppy

The connection is the cause, not the device: frames are dropped rather than queued, so the wall itself is never held up. Lower targetFps to keep full detail at a slower rate.

Rtsp, details

Playing it

Open the url in VLC or ffplay (Watching the output). The second of RTSP and HLS to start reports that the encoder is in use.

One viewer at a time

A new connection takes the session over, and the displaced viewer sees its connection close. A network that blocks the UDP port the viewer names leaves the stream silent (Watching the output).

The delay that remains

H.264 emits a frame once it has the whole frame, and a decoder holds one more, so tens of milliseconds stay. RTSP removes HLS's segment buffering, the seconds.