UCE Resolume Module

Resolume Arena integration for UCE — connect, control, and spatially map a Resolume Arena instance from the UCE control surface.

What is UCE?

UCE is a real-time lighting and show-control platform built around uce-hub: a Rust backend (Axum + Tokio) for DMX runtime, API, persistence, and integrations, paired with a Vue 3 frontend for control, floorplan, scenes, patching, and system management. UCE is extended by dedicated modules maintained in their own repositories. uce-resolume is the module that adds Resolume Arena support to the hub.

This repository ships a small, self-contained Resolume integration: a standalone Rust sidecar that proxies the Resolume REST API, plus a Vue/TypeScript control panel that is compiled into the uce-hub frontend.

Features

Everything below maps to code in this repository:

• Connection management — configure the target Resolume instance (host, port, HTTP/HTTPS, API prefix). Defaults target http://127.0.0.1:8080/api/v1, the Resolume Arena web-server REST API.
• Connection test — probe the Resolume /composition endpoint and report reachability.
• Composition fetch — retrieve and display the live composition payload as JSON.
• Quick actions — one-click composition controls (Play, Pause, Stop, Clear, Blackout on/off, Bypass on/off, Connect/Disconnect all), plus per-layer (Play, Pause, Stop, Clear) and per-clip (Connect, Disconnect, Play, Pause, Stop) actions for a selected layer/clip index.
• Manual command console — send an arbitrary request (path, HTTP method, optional JSON body) to the Resolume REST API through the sidecar.
• Spatial output mapping — position, size, and rotate the output on an interactive screen map (drag, resize, rotate), with the transform persisted alongside the connection settings.
• Screen-size auto-detection — infer the composition’s output dimensions from the Resolume payload and save them.
• Persistent configuration — settings are stored in a JSON config file, written atomically.

Architecture

uce-hub is the host application (Rust core + Vue web). Modules live in uce-hub/modules/<module> and are wired into the hub at build time. The sibling uce-light module is injected directly into the hub’s Rust build via #[path = "../../modules/uce-light/..."] includes; this Resolume module integrates in two complementary ways instead:

• Backend (sidecar). backend/ builds a standalone binary, uce-resolume-backend, that exposes the Resolume proxy HTTP API and, by default, listens on 127.0.0.1:3818. uce-hub launches and supervises this sidecar and proxies its own /api/resolume/* routes to it, so the Resolume backend can be built and updated independently of the hub binary.
• Frontend (compiled in). web/src/ provides the Vue 3 panel and its API client. The hub’s web build consumes these sources (as declared by module.json → frontend.source_root) and bundles the panel into the uce-hub frontend.

module.json describes the module to the hub: its slug (uce_resolume), the API paths it owns (/api/resolume), and the OTA tag prefix (resolume-v). The core/src/ directory holds earlier in-hub integration sources kept for compatibility; the live runtime path is the sidecar plus the hub’s proxy.

Repository layout

Path	Description
backend/	Standalone Rust sidecar (uce-resolume-backend) exposing the Resolume proxy HTTP API
web/src/	Vue 3 + TypeScript control panel consumed by the uce-hub web build
core/src/	Legacy in-hub integration sources kept for compatibility
module.json	Module metadata: slug, protected API paths, OTA tag prefix
LICENSE	GNU General Public License v3

Tech stack

• Backend: Rust (2024 edition), Axum 0.7, Tokio, reqwest (rustls-tls), Serde / serde_json, tracing.
• Frontend: Vue 3 (<script setup>, Composition API) and TypeScript, built with the uce-hub web toolchain (Vite + npm).

Build & run

This module is normally built as part of uce-hub. From an uce-hub checkout, first sync this repository into modules/uce-resolume:

# Linux / macOS
./scripts/bootstrap-resolume-module.sh

# Windows PowerShell
./scripts/bootstrap-resolume-module.ps1

The bootstrap script uses a local sibling checkout (../uce-resolume) when present, and otherwise clones the module from GitHub.

Build the Resolume sidecar (from this repository, or from uce-hub/modules/uce-resolume):

cd backend
cargo build --release
# produces backend/target/release/uce-resolume-backend

Build the frontend as part of the hub (from the uce-hub checkout):

cd web
npm ci
npm run build

The Resolume panel is included automatically once the module has been bootstrapped into uce-hub/modules/uce-resolume.

Running the sidecar directly

For development you can run the backend on its own:

cd backend
cargo run          # listens on 127.0.0.1:3818 by default

The binary also accepts --version / -V and --help / -h.

Environment variables (module backend):

• UCE_RESOLUME_BACKEND_BIND — bind address for the sidecar (default 127.0.0.1:3818).
• UCE_RESOLUME_CONFIG_PATH — path to the persisted config JSON (default modules/uce-resolume/data/config.json).

When run under uce-hub, the hub manages the sidecar process and reaches it through the URL and bind address it configures; the connection to Resolume itself (host, port, prefix, HTTPS) is set from the panel’s Config tab and saved to the config file.

Fixtures

This module controls Resolume output only and needs no fixture data. Lighting fixture profiles are handled elsewhere in UCE (uce-hub / uce-light), sourced from the public Open Fixture Library — no API key required.

Updates

Releases are published through GitHub Releases. Tagging a commit resolume-v<X.Y.Z> builds and publishes a module package containing:

• web/dist — the module UI, integrated into the hub frontend build,
• backend/uce-resolume-backend — the module runtime binary.

Because the package carries the sidecar binary (replace_binary / replace_web_dist), Resolume backend updates ship independently of the core hub-v* releases.

Contributing

Contributions are welcome. Please open an issue to discuss substantial changes, and keep pull requests focused. Before submitting, run the same checks CI enforces:

cd backend
cargo fmt -- --check
cargo clippy -- -D warnings
cargo test

CI also runs the full uce-hub quality suite with uce-resolume injected, so it is worth validating the module inside a bootstrapped uce-hub checkout when your change touches the integration surface.

License

This project is licensed under the GNU General Public License v3.0 or later (GPL-3.0-or-later). See the LICENSE file for the full text.

Copyright (C) 2026 Maxime Deprince