Pixel Streaming¶

Every PoleFX pole is a network pixel fixture. You can stream your own video or generative content to it from lighting and VJ software, exactly as you would to any other LED product, using standards the industry already speaks:

• DDP (Distributed Display Protocol)
• sACN (ANSI E1.31, also called Streaming ACN)
• Art-Net

This page tells you everything needed to drive a pole directly: the pixel layout, the universe math, the settings on each end, and how to check your work without guessing.

This is the opposite approach to the DMX page, and the two are easy to confuse. The difference is what you send and where it lands.

Which generation is your pole?¶

There have been three generations of PoleFX pole, and they differ in ways that matter here. This page describes generation 3, the current product.

Generation 3 raised the resolution around the pole from 8 columns to 12, which is where the current 12 pixel image height comes from.

One thing has always been true of every generation: you send a plain rectangular image and the pole deals with its own wiring. Gen 2 and gen 3 strips physically snake back and forth between their two columns, and gen 1 strips do not, but that is the pole's business. Your content never changes shape because of it.

If you have a gen 1 or gen 2 pole, the protocol options on this page may not be available to you and your frame is not 240 by 12. Read the frame size off the pole itself, as described under Frame size, or get in touch and we will tell you what your specific pole supports.

Before you start¶

You need three things. Check all three before you touch any software: two of the three account for most of the time people lose here.

Everything on this page, including the settings and the diagnostics, arrived in the 2026.07 release. On a pole older than that the Player shows a note in place of the streaming panel, so update the firmware first.

Finding your pole¶

Try these in order. The first one that works is the one to use, and most people never get past the second.

Poles answer to a name. A pole called "Top Support" is reachable at polefx-top-support.local, so you can usually skip the IP address entirely:

curl http://polefx-top-support.local/json/cfg

The name is your pole's name in lowercase with spaces turned into hyphens, and a polefx- prefix. This works out of the box on macOS, on Windows 10 and newer, and on Linux with Avahi installed. It needs no setup, no server, and no special switch or router: poles answer these lookups themselves. The one limit is that it does not cross a router, so you must be on the same network segment as the pole.

You can also list every pole at once. On macOS:

dns-sd -B _http._tcp local

Each pole also publishes its strip and pixel counts alongside its name, so a discovery tool can size a pole without connecting to it.

Finding your pole's IP address¶

If names are not working, or you need the address itself, poles also announce themselves on the network twice a second. The easiest path:

Open the PoleFX Player web app and go to Settings > Devices. Every pole the player can see is listed with its IP address, name, and firmware version. That list is built from the poles' own announcements, so it is current and needs no setup.

If you do not have a player on the network, a pole is still reachable, you just have to find it another way:

• Poles ship with a static IP address, usually in the 192.168.5.x range, and each model has its own default. If you have the paperwork from your installation, the address is on it.
• Any network scanner will find it. nmap -sn 192.168.5.0/24 from a terminal, or a phone app like Fing, will list the devices on the network.
• Once you have a candidate address, confirm it is a pole by opening http://<that-address>/json/cfg in a browser. A pole answers with a block of JSON that starts with its name and profile. Anything else is not a pole.

Connecting a computer straight to a pole¶

You can plug a computer into a pole with a single Ethernet cable, with no switch and no router. One extra step is needed, and skipping it is the usual reason this appears not to work.

Give your computer an address on the pole's network. Poles use a fixed address and do not hand one out, so with a direct cable your computer will assign itself an unrelated address and the two will not be able to reach each other. Set your computer's Ethernet interface to a manual address on the same network as the pole, for example:

• IP address: 192.168.5.100 (any free address on that network)
• Subnet mask: 255.255.255.0
• Router: leave blank

On macOS that is System Settings > Network > Ethernet > Details > TCP/IP, Configure IPv4 set to Manually. On Windows it is the IPv4 properties of the adapter.

Once the addresses match, everything on this page works over that one cable, including the .local name and streaming itself.

The canvas¶

This is the part worth reading carefully. Get the canvas right and everything else is straightforward.

A pole is a rectangular image. Its width is the length of the pole and its height is the distance around the pole. For a standard pole that image is 240 pixels wide by 12 pixels tall.

Think of it as unwrapping the pole into a flat strip: 12 lines of pixels running the length of the pole, side by side. The first pixel of each line is at the top of the pole. The 12 lines wrap around the pole, so the top and bottom edges of your image are physically adjacent, and content that scrolls off the bottom edge should reappear at the top edge.

Pixel order is ordinary reading order. Start at the top-left, go left to right along the first line, then the next line down, and so on. Three bytes per pixel, red then green then blue.

pixel index = (line around the pole * pole length in pixels) + position along the pole

Do not add a zigzag or serpentine. This is the single most common mistake and it is worth stating plainly. Physically, each LED strip inside a gen 3 pole covers two of the 12 lines and the data path snakes back and forth between them. The pole undoes that for you. Your software should send a plain, straightforward image in normal reading order, and the pole rearranges the pixels internally to match its own wiring. If your software offers a "serpentine", "zigzag", "boustrophedon" or "snake" pixel order, leave it off.

This has been true of every generation, including the older poles whose strips are wired differently. The pole always adapts to the image, never the reverse.

Send linear RGB. Do not apply gamma twice. Each pole has its own gamma setting (default 1.0, meaning no correction). If your software also applies gamma, either turn one of them off or accept the combined result. When colors look crushed or washed out, this is almost always the cause.

Frame size¶

The frame size depends on the generation, not on the individual pole. There are only two:

Gen 2 poles are not one shape, so we do not print a number here that might not be yours. Read led.strips and led.pixels from your own pole as described below, or get in touch and we will tell you what that pole expects.

Send the frame size your pole reports. Poles come in different physical lengths, and a shorter pole can expect a smaller frame rather than a padded standard one.

Read it from the pole itself: open http://<pole-ip>/json/cfg and multiply led.strips by led.pixels by 3 to get the bytes it expects. That reading is always the authority for that pole, ahead of any table on this page. If it disagrees with the table above, send what the pole says: a pole handed a frame of the wrong size rejects the excess and may publish nothing at all.

Orientation¶

Pixel 0 is at the top of the pole. The left edge of your image is the top of the pole, and the right edge is the bottom.

This is the part that trips people up, so it is worth being explicit: the image is stored sideways relative to the pole. The pole stands vertically, but its length is the horizontal axis of your image. That means:

If you are preparing footage, the practical consequence is that you usually want to rotate it 90 degrees. A tall video of a flame or a waterfall has to be turned on its side to run along the pole correctly.

If your content comes out upside down while you are streaming, flip the image horizontally in your own software. That reverses the length of the pole and leaves the way round it alone.

The Flipped toggle in a pole's output settings is not the same thing, so do not reach for it to fix a stream. It turns the whole canvas through 180 degrees: the length reverses and the way round the pole mirrors as well. That is the right behavior for a pole mounted the other way up, which is what it is for, and it only applies to content the Player is sending.

Choosing a protocol¶

Use DDP if your software supports it. It carries a whole frame in six packets rather than seventeen, it has an explicit end-of-frame marker so frames never tear, and it is the only one of the three that can multicast a single stream to several poles at once. Software that speaks DDP includes xLights, LedFx, WLED based tools, and the DDP TouchDesigner plugin.

Use sACN or Art-Net if you are driving the pole from lighting or VJ software, which is far more likely to speak those. They are equivalent in practice here. Pick whichever your software supports; if it supports both, either is fine.

Universes¶

sACN and Art-Net both carry 512 channels per universe. Since a pixel takes 3 channels, a universe holds 170 pixels, using 510 channels. The last 2 channels of each universe go unused so that no pixel is split across two universes.

A standard pole is 2,880 pixels, so it needs 17 universes. The first 16 are full (510 channels each) and the 17th carries the remaining 480 channels.

Universes must be consecutive, starting at the pole's start universe.

Setting the start universe¶

Poles default to starting at universe 1, so a standard pole listens on universes 1 through 17.

There are two ways to change it, and they do exactly the same thing.

From the player web app (easiest). Go to Settings > Devices, click Details on the pole you want, and find Streaming protocols. You can turn each protocol on or off, set the start universe, and see live counts of what the pole is receiving. The panel shows how many universes that specific pole needs and which range it is listening on, so you do not have to work it out. Turning a protocol on or off needs a restart; the start universe applies immediately.

Over the pole's own API, which is useful for scripting or when there is no player on the network.

This is the single most common reason a correct-looking setup shows nothing at all, because Art-Net numbers universes from 0 and the pole starts at 1.

To read the current value:

curl http://192.168.5.12/json/cfg

To change the start universe (this example sets it to 0 for Art-Net software that counts from zero) and save it so it survives a reboot:

curl -X POST http://192.168.5.12/json/cfg -d '{"dmx":{"start_uni":0,"sacn_enable":0,"artnet_enable":1},"save":true}'

The start universe applies immediately, with no reboot. Note that sACN cannot use universe 0 (the standard reserves it), so a pole set to 0 is Art-Net only. That is why the example switches sACN off in the same request: leaving it on would advertise a receiver that can no longer be addressed.

You can also turn either receiver off entirely with "sacn_enable":0 or "artnet_enable":0. Those take effect on the next reboot.

The rest of the configuration API¶

/json/cfg is not limited to these settings. A GET returns the pole's entire configuration, and whatever it returns it will also accept back on a POST, which is what makes it usable as a backup format rather than just an API. It covers the device name and profile, network addresses, ports, LED geometry and gamma, idle patterns, on-pole text, and the protocol settings above.

Two rules the pole enforces, both worth relying on:

• A change is all or nothing. The pole validates the whole document before applying any of it. If one field is out of range it rejects the entire request with an error naming that field, and nothing on the pole changes. There is no half-applied state to clean up. Values are never quietly clamped to fit.
• Nothing persists until you ask. Add "save":true to write the change to the pole's permanent storage. Without it the change is live immediately but will be lost on the next power cycle.

A successful response looks like this:

{"ok":true,"applied":3,"saved":true,"save_error":0,"restart_required":false}

A rejected one is an HTTP 400 whose message names the field, for example 1 field(s) rejected, first: start_uni: out of range.

To back up a pole, save the output of a GET. To restore it, POST that file back with "save":true. Because everything the pole reports is also something it accepts, a backup taken from one pole can be pushed to another.

Setting up Resolume¶

Resolume is a good choice for streaming video content to poles. Some requirements to know before you start:

• Resolume Arena, not Avenue. Pixel output over Art-Net is an Arena-only feature. Avenue cannot do it.
• These steps use Art-Net. Recent versions of Arena also offer sACN output, but we have not tested that path against a pole. If you use it, remember the pole is unicast only, so give it the pole's IP address rather than leaving sACN on multicast.
• The free demo version does DMX output; it watermarks the video output.

Resolume's own reference for this is its DMX Output and Fixture Editor manual pages.

1. Build the fixture¶

Open Application > Fixture Editor and create a new fixture.

• Width 240, Height 12 for a standard pole. Use the sizes from the table above for other models.
• Distribution: choose plain reading order, going left to right and top to bottom. Do not choose a zigzag or serpentine option. The pole applies its own internal zigzag; adding one here scrambles the image.
• Color Space: RGB.
• Gamma: Resolume defaults this to 2.5. The pole's own gamma defaults to 1.0 (off), so leaving Resolume at 2.5 gives you a normal gamma curve overall. Change it only if the result looks wrong.

2. Create the output¶

Open Output > Advanced... to open the Advanced Output window.

1. From the Presets dropdown choose New for a blank layout.
2. Click the + icon and add a DMX Lumiverse. A Lumiverse is Resolume's virtual container for a set of universes.
3. If you are only doing LED output, select Screen 1 and delete it.
4. The Lumiverse creates a DMX Fixture automatically. Select it and choose your pole fixture from the Fixture dropdown at the bottom right.
5. Position and scale the fixture in the Input Selection canvas. This decides which part of your composition the pole samples.

3. Point it at the pole¶

Select the Lumiverse and set, on the right-hand panel:

• TargetIP: choose IP Address and type the pole's address. Resolume can also auto-discover Art-Net nodes, but poles do not announce themselves, so enter the address manually.
• Subnet 0 and Universe 1, to match a pole using its default start universe. Type the universe number the pole is listening on: Resolume's field is the number that goes on the wire, so 1 here reaches a pole that starts at 1. The off-by-one warned about above is what happens when software starts its own count at 0 and you leave the field there; here you are setting it explicitly, so there is nothing to convert.
• Auto Span: on. This lets the Lumiverse grow past one universe automatically, which a 17 universe pole needs.
• Align Output: on. This stops a pixel from being split across two universes. Poles reject packets where pixels straddle a universe boundary, so this must stay on.

4. Settings worth changing¶

In Preferences > DMX:

• Network Adapter: pick the interface your poles are on. Sending to the wrong adapter is the most common reason nothing appears. Note that this switches Art-Net input and output together.
• Output Delay: defaults to 40 ms, which exists to line lights up with projectors. With no projector in the rig, set it to 0.
• Output Framerate: poles accept up to 60 frames per second.

The Output > Test Card has a moving diagonal line, which makes a flipped or misordered fixture obvious immediately.

Checking your work¶

Every pole reports what it is receiving. Open this in a browser:

http://<pole-ip>/json/cfg

Look at the info section for sacn, artnet or ddp. The useful fields:

Test frames¶

Seven frames that each answer one question. They are 240 by 12 PNGs, the exact canvas a gen 3 pole expects, so you can send them straight through your software without resizing. Each preview below is magnified four times; the download is the real thing.

• 
  Gradient 240 x 12 Download the frame
• 
  Row colors 240 x 12 Download the frame
• 
  Seam 240 x 12 Download the frame
• 
  Landmarks 240 x 12 Download the frame
• 
  Universe bands 240 x 12 Download the frame
• 
  RGB bars 240 x 12 Download the frame
• 
  Checkerboard 240 x 12 Download the frame

These are generated by tools/make_test_patterns.py, so they always match the canvas this page describes.

If nothing is displaying¶

The pole's own counters tell you which of these it is, so read them before changing anything. Each branch below ends in one thing to do.

Limits and behavior¶

• 60 frames per second is what we test and recommend. Nothing in the pole rejects a faster stream, but frames that arrive before the previous one has been shown are simply superseded, so the extra work is wasted.
• A pole displays whichever source is actively streaming. A different protocol can take over once the current one has been quiet for half a second. A second sender on the same protocol is ignored until the first has been quiet for a quarter of a second.
• When streaming stops entirely, the pole returns to its built-in patterns after a few seconds.
• A frame is only displayed once all of it has arrived, so a dropped packet holds the previous frame rather than showing a torn one.