Downloads

Choose your platform.

Every download is built from the current GitHub release. Start with the standalone Windows executable, or choose a universal macOS app or Linux x86_64 archive.

WIN

Windows

Windows 10 and later, x86_64. One executable with the Microsoft runtime and built-in profiles included. No installer, Rust toolchain, or companion files required.

Download for Windows

If Windows SmartScreen appears on first launch, click More info, then Run anyway. The executable is not code-signed yet, so Windows asks once per download.

MAC

macOS

Universal app for Apple Silicon and Intel Macs. Unzip the download and move DMXexpress to Applications.

Download for macOS

Requires macOS 11 or later. The app is not notarized yet: if macOS blocks the first launch, click Done, then open System Settings > Privacy & Security, scroll to Security, and click Open Anyway. On older macOS versions, right-click the app and choose Open instead.

LNX

Linux

x86_64 binary for a desktop with Wayland or X11 and ALSA audio. Extract the archive, make the binary executable if necessary, then run it.

Download for Linux

System graphics and audio drivers are still required.

The DMXexpress console after launch: the Fixtures panel on the left, the 3D stage with lit beams in the centre, the Inspector on the right, and channel control below
This is the whole app, one window, straight out of the download — fixtures left, 3D stage centre, Inspector right, channel control below.

All three builds come out of the same tagged release, compiled by GitHub Actions from the public source. Nothing is repackaged by hand.

What you get

One file. Everything inside it.

There is no installer, no redistributable, and no folder of assets sitting next to the app. The fixture library, the gobo catalogue, the fonts, the sample shows and the starter plugins are all compiled into the binary.

Built in, not bundled.

Everything the app needs to patch a rig and light it is inside the executable you downloaded:

  • The fixture library — about 7,400 patchable modes from roughly 2,200 models across 210 manufacturers, compressed into the binary and unpacked on first run.
  • The gobo catalogue — around 1,000 gobo images plus the wheel maps that say which image sits in which DMX range, so beams project real patterns.
  • The interface fonts — Inter and JetBrains Mono ship inside the app, so the console looks the same on a machine with nothing installed.
  • Two sample shows and three stage setups — a rig you can open and run before you have patched anything of your own.
  • Three starter plugins — the .rhai scripts that ship with the app, written to the plugins folder on first run.
  • On Windows, the C runtime — statically linked, so a clean Windows install needs no Visual C++ redistributable.
The DMXexpress Patch window with the built-in fixture library open and search results listing fixture modes
The Patch window searching the built-in library — no download, no account, no internet.
Release assets
DMXpress-windows-x86_64.exe          # the app — run it, that is all
DMXpress-windows-x86_64.exe.sha256   # checksum for the line above
DMXpress-macos-universal.zip         # DMXpress.app, Apple Silicon + Intel
DMXpress-linux-x86_64.tar.gz         # one binary named dmxpress
The DMXexpress Gobos window showing a grid of gobo thumbnails from the built-in catalogue
The gobo catalogue ships inside the app — no image packs to hunt down.
The DMXexpress 3D stage filling the frame with movers and pars throwing coloured volumetric beams and floor pools
The visualizer runs on your GPU through wgpu. No physical lights needed to program a show.

Before you download

What it needs from your machine.

DMXexpress renders its 3D stage on the GPU, so a working graphics driver matters more than a fast CPU. Everything else is modest.

WIN

Windows

  • Windows 10 or later, 64-bit
  • A GPU and driver that wgpu supports
  • No Visual C++ redistributable
  • No administrator rights to run it
MAC

macOS

  • macOS 11 Big Sur or later
  • Apple Silicon or Intel — one universal build
  • Microphone permission if you use audio triggers
  • ShowBuddy patch import is optional, not required
LNX

Linux

  • x86_64 desktop on Wayland or X11
  • ALSA for audio input
  • udev for the Stream Deck over USB
  • Working Vulkan or OpenGL drivers

The window opens at 1440 × 900 and will not go below 960 × 640.

The console packs a fixture list, a 3D stage, a five-tab Inspector and a channel grid into one window, so it wants room. A laptop screen works; a small one will have you folding panels. The Inspector's width and folded sections are remembered per machine, not per show.

Connections

What the app talks to.

Three things leave the machine: DMX over the network, key images to a Stream Deck over USB, and audio coming in. Nothing else.

NET

Art-Net and sACN

Two contiguous universes — 1,024 channels — sent at 40 frames per second. Art-Net goes out on UDP 6454, sACN multicasts on UDP 5568, and you can run either or both at once. Art-Net node discovery finds what is on the wire.

Output in the guide
USB

Elgato Stream Deck

Plugged straight into USB and picked up by the app itself — no Elgato software, no plugin to install. Original, Mini, MK2, XL, Neo, Pedal, Plus and Plus XL are all recognised, and unplugging mid-show just makes the app rescan until one comes back.

See the deck pages
AUD

Audio input

Any input device the system offers drives the sound-reactive triggers. On Windows the app can also open an output device in loopback, so it listens to whatever the computer is already playing and lights to it.

Audio in the guide
The DMXexpress Network window listing discovered Art-Net nodes alongside the output checklist
The Network window: discovered nodes, per-universe traffic, and a checklist that names what is wrong before a show does.
The DMXexpress Audio window showing a live frequency spectrum with a trigger band selected
The Audio window: pick a device, drag a band across the spectrum, and trigger from it.

Hardware is plug and play.

An Elgato Stream Deck is detected the moment it is plugged in — no Elgato software or plugins needed. Audio input works out of the box too: on Windows, DMXexpress can listen to the computer's own output and light whatever is playing.

Check the patch before you touch a live rig

DMXexpress transmits real lighting data. Confirm the network interface, the universe, the patch and the Grand Master before you connect it to anything with a lamp in it.

First run

What happens when you open it.

Nothing to configure, nothing to register. The app works out where your show data belongs, seeds it, and opens on a rig you can already play with.

  1. 1

    It looks for a show beside itself

    If the folder it was launched from already holds a settings.json or a stage_layout.json, that is your show and the app uses it. A folder per show works exactly the way you would hope.

  2. 2

    Otherwise it picks a per-user folder

    A binary run from Downloads has no show beside it, so the app switches to a per-user data folder instead of scattering JSON through your Downloads — or losing it inside a translocated macOS app bundle.

  3. 3

    It seeds that folder

    configs/, setups/, fixtures/ and plugins/ are created, then filled with the two sample shows, the three stage setups, the three starter plugins, the fixture library and the gobo catalogue.

  4. 4

    The console opens

    Load a sample setup, select the rig, and push some channels. Everything in the 3D stage responds live, with or without a single fixture plugged in.

Where show data lands
# Windows
%APPDATA%\DMXpress

# macOS
~/Library/Application Support/DMXpress

# Linux
~/.local/share/DMXpress

Show files stay separate from the app.

On first launch, DMXexpress creates its show-data folder and seeds it with sample rigs, stage setups, the 2,200-model fixture library, and the gobo catalogue. Your work persists there, rather than being written beside the downloaded application.

Your show is plain JSON.

Palettes, groups, presets, phasers, sequences, stacks, views, patch data, the stage layout, saved cameras, the Presets board and settings are all human-readable files you can open, read, diff and keep in version control.

Complete shows live under configs/; reusable stage arrangements live under setups/. Panel preferences that belong to the machine rather than the show — the Inspector's open tab and width, which sections are folded, what the stage draws — sit apart in inspector.json and are deliberately left out of saved configurations, so loading someone else's show never rearranges your workspace.

Formats may still change while the project is under active development. Keep a backup of anything valuable, or put the folder under version control.

The DMXexpress Settings window showing application options and file locations
Settings, like everything else, is written back as readable JSON in the show folder.

Verify

Check what you downloaded.

The Windows executable ships with a SHA-256 checksum written by the build job that produced it. Download both, hash the file yourself, compare the two strings.

Windows — PowerShell
# the checksum the release published
curl.exe -LO https://github.com/michaelmandich/DMXpress/releases/latest/download/DMXpress-windows-x86_64.exe.sha256

# the checksum of the file on your disk
(Get-FileHash .\DMXpress-windows-x86_64.exe -Algorithm SHA256).Hash.ToLower()

# they must match, character for character
Get-Content .\DMXpress-windows-x86_64.exe.sha256

The macOS and Linux archives do not carry a checksum file yet. GitHub serves them over HTTPS from the release that built them, and the macOS app is ad-hoc signed during the build so the bundle's own contents cannot be swapped without macOS noticing.

Every asset is produced by the release workflow on GitHub's runners from the tagged commit — you can read exactly how each file was built.

From source

Or build it yourself.

DMXexpress is MPL-2.0 and the whole tree is public. If you would rather compile it than trust a binary, it is one cargo command away.

What you need first.

  • A current stable Rust toolchain with Cargo
  • A GPU and driver supported by wgpu
  • On Linux: libasound2-dev, libudev-dev and pkg-config
  • Nothing else — every asset is in the repository

A release build links with lto = "thin" and a single codegen unit, so the first compile takes a while and the result runs like the download does. Run the app from a folder that holds your show files and it will use them directly.

Read the source on GitHub

The DMXexpress 3D stage showing truss and tower structures with fixtures hung on them
Same app either way — built from source or downloaded, the rig is identical.
Clone, build, run
git clone https://github.com/michaelmandich/DMXpress
cd DMXpress

# Debian/Ubuntu only
sudo apt-get install -y libasound2-dev libudev-dev pkg-config

# run it
cargo run

# optimized build
cargo build --release
./target/release/dmxpress

# run the tests
cargo test