What Is Interactive Art and How Do Artists Create Interactive Installations?

Interactive art is artwork that changes in response to input — a viewer's movement, a sensor reading, a sound, or a network signal. The artist designs a system that senses something, decides what to do with it, and produces output (light, sound, video, motion). Building one usually means combining three layers: input (sensors, controllers, MIDI/OSC devices), logic (a sequencer, script, or state machine that maps input to output), and output (audio, video, lighting, motors). Tools like ossia score exist specifically to handle the middle layer — scripting and sequencing interactive scenarios across many media types and protocols at once.

What makes art "interactive"

The defining feature is a feedback loop: the work responds to something outside itself, and that response can change over time or branch based on conditions. This separates it from static media (a painting, a fixed video) and from purely generative digital art that runs on its own without external input.

Common forms include:

• Responsive installations — a room that reacts to visitors' presence, motion, or touch
• Interactive performances — musicians or dancers triggering and shaping media live
• Media art shows — multi-screen or multi-channel works driven by sensors and data
• Networked or IoT works — pieces that read from or control connected devices

How interactivity works technically

Underneath, most interactive art follows the same pattern: a device or sensor produces a signal, software interprets it, and that interpretation drives output. The signal travels over a protocol.

According to ossia's documentation, these protocols are implemented behind a common interface in libossia, so any application using libossia can support, bridge, or translate between them. That matters for interactive art because a single installation often mixes several protocols — say, a MIDI controller, an OSC-driven video system, and DMX lights — and something has to keep them in sync.

Tools artists use to script interactive scenarios

Two broad categories of software show up in interactive work:

Creative coding environments — Max/MSP, Pure Data, openFrameworks, Processing, and glslViewer are commonly used to build custom visuals, sound, and sensor logic. ossia states that you can connect to these either through a traditional OSC connection, through the more advanced OSCQuery protocol, or through direct integration of libossia.

Intermedia sequencers — software built to arrange and trigger multiple media types on a timeline. ossia score is described as a free, open-source, cross-platform intermedia sequencer for "precise and flexible scripting of interactive scenarios." Its documented capabilities include:

• Sequencing audio (most formats, including multichannel), H.264 and HAP video, and a cross-platform video and shader pipeline on an intelligent timeline
• Sending and receiving OSC, MIDI, DMX, HTTP, and serial
• Controlling IoT systems via CoAP, MQTT, and BLE
• Triggering any part of the score from external conditions or hardware controls
• Using conditions to create branching scores visually
• Switching between a timeline view and a nodal (modular) view at any point
• Nesting and grouping without depth limit
• Embedding multiple programming languages: livecoding with JavaScript directly in the score, audio processors in Faust, math expressions for quick control, and extension through a C++ API

The combination of timeline and node-based editing is what makes this class of tool suited to interactive work: a timeline handles "what happens when," while nodes handle "what connects to what."

From concept to running installation

A practical workflow for an interactive piece looks like this:

1. Define the interaction. Decide what the audience does and what the work senses — motion, sound level, button press, proximity.
2. Choose input hardware and protocol. A camera, distance sensor, gamepad, or MIDI controller, communicating over OSC, MIDI, serial, or another supported protocol.
3. Build the logic. Map input values to outputs. This is where conditions and branching matter: "if the visitor moves left, play clip A; if they stay, loop B." ossia score supports triggering parts of a score on external conditions and creating branching scores visually.
4. Connect outputs. Audio, video, lighting (DMX), or networked devices. Protocols like MQTT and CoAP extend this to IoT hardware.
5. Test and iterate. Run the piece with real input and adjust thresholds, timing, and mappings. Livecoding (JavaScript in the score) or math expressions let you tune behavior without rebuilding.

A common sticking point is synchronization: when several protocols and media types run at once, timing drift and mismatched control ranges cause visible glitches. Using a single sequencer that speaks all the protocols — rather than chaining separate tools — reduces that class of problem.

Where this shows up in practice

Interactive art appears in galleries and festivals as responsive installations, on stage as media-enhanced performances, and in public or architectural spaces as sensor-driven lighting and sound. ossia's own gallery lists works such as Musical, Nebula, and Four For, and its blog includes a case study titled "[re]capture" — examples of the kind of intermedia, protocol-heavy projects these tools are built for.

If you're starting out, the practical question is less "what is interactive art" and more "what does my piece need to sense, decide, and output." Pick the protocol your input device speaks, choose a tool that can sequence your output media types, and keep the logic in one place so the interaction stays coherent.