Creative Low-Latency Application Streaming Protocol

CLASP is a universal protocol bridge and signal router for creative applications. It unifies disparate protocols (OSC, MIDI, DMX, Art-Net, MQTT, WebSocket, HTTP) into a single, routable message system optimized for real-time performance.

Creative projects often involve a chaotic mix of protocols:

• Lighting speaks DMX and Art-Net
• Audio software uses OSC and MIDI
• IoT sensors communicate via MQTT
• Web interfaces need WebSocket or HTTP
• VJ software has its own proprietary APIs

CLASP acts as the universal translator, letting everything talk to everything else through a unified address space.

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  TouchOSC   │     │   Ableton   │     │  LED Strip  │
│  (OSC)      │     │   (MIDI)    │     │  (Art-Net)  │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       └───────────────────┼───────────────────┘
                           │
                    ┌──────▼──────┐
                    │    CLASP    │
                    │   Router    │
                    └──────┬──────┘
                           │
       ┌───────────────────┼───────────────────┐
       │                   │                   │
┌──────▼──────┐     ┌──────▼──────┐     ┌──────▼──────┐
│  Web UI     │     │  IoT Hub    │     │  Resolume   │
│ (WebSocket) │     │  (MQTT)     │     │  (OSC)      │
└─────────────┘     └─────────────┘     └─────────────┘

cargo install clasp-cli

Download the latest release for your platform:

• macOS: CLASP Bridge.dmg
• Windows: CLASP Bridge Setup.exe
• Linux: clasp-bridge.AppImage

Important: CLASP uses a router-based architecture. Start a router first, then add protocol connections.

# 1. Start CLASP router (required - central message hub)
clasp server --port 7330

# 2. Start protocol connections (these connect TO the router)
# OSC: listens for OSC messages, translates and routes to CLASP
clasp osc --port 9000

# MQTT: connects to MQTT broker, translates and routes to CLASP
clasp mqtt --host broker.local --port 1883

# HTTP: provides REST API that translates to CLASP
clasp http --bind 0.0.0.0:3000

# Show all options
clasp --help

How it works: Protocol commands (clasp osc, clasp mqtt, etc.) create bidirectional protocol connections that connect to the CLASP router. They translate between external protocols and CLASP, routing all messages through the central router. This enables any protocol to communicate with any other protocol through CLASP.

See Bridge Setup Guide for detailed setup instructions.

CLASP clients can communicate directly with each other through a CLASP router. Here are examples in each supported language:

Server (Node.js):

import { ClaspBuilder } from '@clasp-to/core';

// Connect to router
const server = await new ClaspBuilder('ws://localhost:7330')
  .withName('LED Controller')
  .connect();

// Listen for brightness changes
server.on('/lights/*/brightness', (value, address) => {
  console.log(`Setting ${address} to ${value}`);
  // Control actual LED hardware here
});

// Publish current state
await server.set('/lights/strip1/brightness', 0.8);

Client (Browser or Node.js):

import { ClaspBuilder } from '@clasp-to/core';

const client = await new ClaspBuilder('ws://localhost:7330')
  .withName('Control Panel')
  .connect();

// Control the lights
await client.set('/lights/strip1/brightness', 0.5);

// Read current value
const brightness = await client.get('/lights/strip1/brightness');
console.log(`Current brightness: ${brightness}`);

// Subscribe to changes from other clients
client.on('/lights/**', (value, address) => {
  console.log(`${address} changed to ${value}`);
});

Publisher:

import asyncio
from clasp import ClaspBuilder

async def main():
    client = await (
        ClaspBuilder('ws://localhost:7330')
        .with_name('Sensor Node')
        .connect()
    )

    # Publish sensor data
    while True:
        temperature = read_sensor()  # Your sensor code
        await client.set('/sensors/room1/temperature', temperature)
        await asyncio.sleep(1)

asyncio.run(main())

Subscriber:

import asyncio
from clasp import ClaspBuilder

async def main():
    client = await (
        ClaspBuilder('ws://localhost:7330')
        .with_name('Dashboard')
        .connect()
    )

    # React to sensor updates
    @client.on('/sensors/*/temperature')
    def on_temperature(value, address):
        print(f'{address}: {value}°C')

    # Keep running
    await client.run()

asyncio.run(main())

Publisher:

use clasp_client::{Clasp, ClaspBuilder};
use clasp_core::Value;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = ClaspBuilder::new("ws://localhost:7330")
        .name("Rust Publisher")
        .connect()
        .await?;

    // Set values that other clients can subscribe to
    client.set("/app/status", Value::String("running".into())).await?;
    client.set("/app/counter", Value::Int(42)).await?;

    // Stream high-frequency data
    for i in 0..100 {
        client.set("/app/position", Value::Float(i as f64 * 0.1)).await?;
        tokio::time::sleep(std::time::Duration::from_millis(16)).await;
    }

    client.close().await?;
    Ok(())
}

Subscriber:

use clasp_client::{Clasp, ClaspBuilder};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = ClaspBuilder::new("ws://localhost:7330")
        .name("Rust Subscriber")
        .connect()
        .await?;

    // Subscribe to all app signals
    let _unsub = client.subscribe("/app/**", |value, address| {
        println!("{} = {:?}", address, value);
    }).await?;

    // Keep running
    tokio::signal::ctrl_c().await?;
    client.close().await?;
    Ok(())
}

CLASP clients in different languages can seamlessly communicate:

┌────────────────────┐     ┌─────────────────┐     ┌────────────────────┐
│   Python Sensor    │     │  CLASP Router   │     │  JS Web Dashboard  │
│                    │────▶│  (port 7330)    │◀────│                    │
│ set('/temp', 23.5) │     │                 │     │ on('/temp', ...)   │
└────────────────────┘     └─────────────────┘     └────────────────────┘
                                   ▲
                                   │
                           ┌───────┴───────┐
                           │ Rust Actuator │
                           │               │
                           │ on('/temp',   │
                           │   adjust_hvac)│
                           └───────────────┘

• Protocol Connections: OSC, MIDI, Art-Net, DMX, MQTT, WebSocket, Socket.IO, HTTP/REST
• Signal Routing: Wildcard patterns (*, **), transforms, aggregation
• Low Latency: WebSocket transport with sub-millisecond overhead
• State Sync: Automatic state synchronization between clients
• Desktop App: Visual protocol configuration and signal monitoring
• CLI Tool: Start routers and protocol connections from the command line
• Embeddable: Rust crates, WASM module, Python, JavaScript

We believe in transparent benchmarking with honest methodology.

These measure raw encode/decode speed—the theoretical ceiling, not system throughput:

⚠️ Important: These are codec-only numbers (no network, no routing, no state). Real system throughput is 10-100x lower depending on features enabled.

Actual measured performance on localhost (macOS, M-series):

Run benchmarks yourself:

cargo run --release -p clasp-e2e --bin latency-benchmarks
cargo run --release -p clasp-e2e --bin chaos-tests

CLASP uses efficient binary encoding that is 55% smaller than JSON:

JSON: {"type":"SET","address":"/test","value":0.5,...} → ~80 bytes
CLASP: [SET][flags][len][addr][value][rev]             → 31 bytes

• LAN (wired): Target ±1ms clock sync accuracy
• WiFi: Target ±5-10ms clock sync accuracy
• Not suitable for: Hard realtime, safety-critical, industrial control systems

CLASP is designed for soft realtime creative applications: VJ software, stage lighting, music production, interactive installations.

CLASP supports multiple network transports for different use cases:

Enable transports with feature flags:

# Default (WebSocket + UDP + QUIC)
cargo add clasp-transport

# All transports
cargo add clasp-transport --features full

# Specific transports
cargo add clasp-transport --features "websocket,quic,serial"

Visit clasp.to for full documentation.

• Getting Started
• Protocol Specification
• API Reference
• Examples

• Rust 1.75+
• Node.js 20+ (for desktop app)
• Platform-specific dependencies:
  • Linux: libasound2-dev, libudev-dev
  • macOS: Xcode Command Line Tools

# Clone the repository
git clone https://github.com/lumencanvas/clasp.git
cd clasp

# Build all Rust crates
cargo build --release

# Build desktop app
cd apps/bridge
npm install
npm run build

cargo test --workspace

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

CLASP builds on the shoulders of giants:

• Quinn - QUIC implementation
• rosc - OSC codec
• midir - MIDI I/O
• rumqttc - MQTT client

Maintained by LumenCanvas | 2026