diff --git a/README.md b/README.md
index 11b9d11..6c06012 100644
--- a/README.md
+++ b/README.md
@@ -92,20 +92,24 @@ This node can be used to record scenes and play them afterwards.
 
 #### Parameters:
 
-| Parameter | Description                                                                    | Possible Values       | Default Value | Mandatory |
-| --------- | ------------------------------------------------------------------------------ | --------------------- | ------------- | --------- |
-| values    | Interpret channel values as a percentage (0–100) or as raw DMX values (0–255). | `percent`, `absolute` | `percent`     | yes       |
+| Parameter      | Description                                                                                                                | Possible Values       | Default Value | Mandatory |
+| -------------- | -------------------------------------------------------------------------------------------------------------------------- | --------------------- | ------------- | --------- |
+| values         | Interpret channel values as a percentage (0–100) or as raw DMX values (0–255).                                             | `percent`, `absolute` | `percent`     | yes       |
+| playMode       | Whether a new `play` replaces the running look (`switch`) or stacks scenes additively, combined per channel by HTP (`add`) | `switch`, `add`       | `switch`      | yes       |
+| blackoutOnStop | Send a nulled universe once when the last active scene is stopped, so the output goes dark.                                | `true`, `false`       | `false`       | no        |
 
 Recorded scenes are stored on disk (in a `sacn-scenes` directory inside the Node-RED user directory) and survive a restart.
 
+In `add` mode multiple scenes can be active at once; every `play`, `stop` or `reset` recomputes the combined look (highest value wins per channel) and emits it once. The output only goes dark once the last active scene ends.
+
 #### Expected input:
 
-| Property   | Description                                                                                                                                                                                                                                                                          | Mandatory                       |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------- |
-| `action`   | the action to be executed - `save` to save a preset, `play` to play a saved preset, `reset` to reset                                                                                                                                                                                 | yes                             |
-| `scene`    | for action                                                                                                                                                                                                                                                                           | yes, for actions `save`, `play` |
-| `universe` | if only one universe is handled, this parameter is mandatory and contains the used universe                                                                                                                                                                                          | only for a single universe      |
-| `payload`  | contains the values to record. it might be an array (key 0-511) containing the values for a single universe,<br/>an object (keys 1-512) containing the values for a single universe or<br/>an object (any numeric keys) containing objects (keys 1-512) containing an universe each. | yes, for action `save`          |
+| Property   | Description                                                                                                                                                                                                                                                                          | Mandatory                               |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------- |
+| `action`   | the action to be executed - `save` to save a preset, `play` to play a saved preset, `stop` to stop a preset while keeping it stored, `reset` to reset                                                                                                                                | yes                                     |
+| `scene`    | for action                                                                                                                                                                                                                                                                           | yes, for actions `save`, `play`, `stop` |
+| `universe` | if only one universe is handled, this parameter is mandatory and contains the used universe                                                                                                                                                                                          | only for a single universe              |
+| `payload`  | contains the values to record. it might be an array (key 0-511) containing the values for a single universe,<br/>an object (keys 1-512) containing the values for a single universe or<br/>an object (any numeric keys) containing objects (keys 1-512) containing an universe each. | yes, for action `save`                  |
 
 #### Output for single universe:
 
@@ -115,6 +119,7 @@ Recorded scenes are stored on disk (in a `sacn-scenes` directory inside the Node
 | `payload`  | Array containing the dmx values as **percentage** by dmx channel. DMX-Channel `1` starts at key `1`, not `0`. (`Array<number, number>`) |
 | `scene`    | The scene that is played (`number`)                                                                                                     |
 | `reset`    | Identifies a reset message for action `reset`, otherwise it does not exist. (`true`)                                                    |
+| `stopped`  | Identifies the nulled message emitted for action `stop` (when `blackoutOnStop` is enabled), otherwise it does not exist. (`true`)       |
 
 #### Output for multiple universes:
 
@@ -124,6 +129,7 @@ Recorded scenes are stored on disk (in a `sacn-scenes` directory inside the Node
 | `payload`  | Object containing one object per universe. DMX-Channel `1` starts at key `1`, not `0`. (`object<number, object<number, number>>`) |
 | `scene`    | The scene that is played (`number`)                                                                                               |
 | `reset`    | Identifies a reset message for action `reset`, otherwise it does not exist. (`true`)                                              |
+| `stopped`  | Identifies the nulled message emitted for action `stop` (when `blackoutOnStop` is enabled), otherwise it does not exist. (`true`) |
 
 ## Protocol notes and limitations
 
diff --git a/dist/lib/dmx.js b/dist/lib/dmx.js
index 598c8f3..287e24e 100644
--- a/dist/lib/dmx.js
+++ b/dist/lib/dmx.js
@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_ABSOLUTE = exports.MAX_PERCENT = exports.LAST_UNIVERSE = exports.FIRST_UNIVERSE = exports.LAST_CHANNEL = exports.FIRST_CHANNEL = void 0;
+exports.MAX_ABSOLUTE =
+  exports.MAX_PERCENT =
+  exports.LAST_UNIVERSE =
+  exports.FIRST_UNIVERSE =
+  exports.LAST_CHANNEL =
+  exports.FIRST_CHANNEL =
+    void 0;
 exports.maxValue = maxValue;
 exports.fromPercent = fromPercent;
 exports.nulledUniverse = nulledUniverse;
@@ -11,15 +17,15 @@ exports.LAST_UNIVERSE = 63999;
 exports.MAX_PERCENT = 100;
 exports.MAX_ABSOLUTE = 255;
 function maxValue(scale) {
-    return scale === "absolute" ? exports.MAX_ABSOLUTE : exports.MAX_PERCENT;
+  return scale === "absolute" ? exports.MAX_ABSOLUTE : exports.MAX_PERCENT;
 }
 function fromPercent(percent, scale) {
-    return scale === "absolute" ? Math.round(percent * 2.55) : percent;
+  return scale === "absolute" ? Math.round(percent * 2.55) : percent;
 }
 function nulledUniverse() {
-    const universe = {};
-    for (let channel = exports.FIRST_CHANNEL; channel <= exports.LAST_CHANNEL; channel++) {
-        universe[channel] = 0;
-    }
-    return universe;
+  const universe = {};
+  for (let channel = exports.FIRST_CHANNEL; channel <= exports.LAST_CHANNEL; channel++) {
+    universe[channel] = 0;
+  }
+  return universe;
 }
diff --git a/dist/lib/interfaces.js b/dist/lib/interfaces.js
index df0c2e9..bcde03f 100644
--- a/dist/lib/interfaces.js
+++ b/dist/lib/interfaces.js
@@ -4,24 +4,24 @@ exports.listInterfaces = listInterfaces;
 exports.registerInterfaceEndpoint = registerInterfaceEndpoint;
 const node_os_1 = require("node:os");
 function listInterfaces() {
-    const result = [];
-    const interfaces = (0, node_os_1.networkInterfaces)();
-    for (const name of Object.keys(interfaces)) {
-        for (const info of interfaces[name] ?? []) {
-            if (info.family === "IPv4") {
-                result.push({ name, address: info.address });
-            }
-        }
+  const result = [];
+  const interfaces = (0, node_os_1.networkInterfaces)();
+  for (const name of Object.keys(interfaces)) {
+    for (const info of interfaces[name] ?? []) {
+      if (info.family === "IPv4") {
+        result.push({ name, address: info.address });
+      }
     }
-    return result;
+  }
+  return result;
 }
 let registered = false;
 function registerInterfaceEndpoint(RED) {
-    if (registered) {
-        return;
-    }
-    registered = true;
-    RED.httpAdmin.get("/sacn/interfaces", RED.auth.needsPermission("flows.read"), (_req, res) => {
-        res.json(listInterfaces());
-    });
+  if (registered) {
+    return;
+  }
+  registered = true;
+  RED.httpAdmin.get("/sacn/interfaces", RED.auth.needsPermission("flows.read"), (_req, res) => {
+    res.json(listInterfaces());
+  });
 }
diff --git a/dist/lib/network.js b/dist/lib/network.js
index e622fea..266b18a 100644
--- a/dist/lib/network.js
+++ b/dist/lib/network.js
@@ -5,11 +5,11 @@ exports.resolveNetworkOptions = resolveNetworkOptions;
 const node_net_1 = require("node:net");
 exports.DEFAULT_PORT = 5568;
 function resolveNetworkOptions(config) {
-    const options = {
-        port: config.port !== undefined && config.port > 0 ? config.port : exports.DEFAULT_PORT,
-    };
-    if (config.interface !== undefined && (0, node_net_1.isIP)(config.interface) === 4) {
-        options.iface = config.interface;
-    }
-    return options;
+  const options = {
+    port: config.port !== undefined && config.port > 0 ? config.port : exports.DEFAULT_PORT,
+  };
+  if (config.interface !== undefined && (0, node_net_1.isIP)(config.interface) === 4) {
+    options.iface = config.interface;
+  }
+  return options;
 }
diff --git a/dist/lib/scene-store.js b/dist/lib/scene-store.js
index 70d7770..8ca7c56 100644
--- a/dist/lib/scene-store.js
+++ b/dist/lib/scene-store.js
@@ -4,25 +4,24 @@ exports.SceneStore = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 class SceneStore {
-    file;
-    constructor(baseDir, nodeId) {
-        const dir = (0, node_path_1.join)(baseDir, "sacn-scenes");
-        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-        this.file = (0, node_path_1.join)(dir, `${nodeId}.json`);
+  file;
+  constructor(baseDir, nodeId) {
+    const dir = (0, node_path_1.join)(baseDir, "sacn-scenes");
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    this.file = (0, node_path_1.join)(dir, `${nodeId}.json`);
+  }
+  load() {
+    if (!(0, node_fs_1.existsSync)(this.file)) {
+      return {};
     }
-    load() {
-        if (!(0, node_fs_1.existsSync)(this.file)) {
-            return {};
-        }
-        try {
-            return JSON.parse((0, node_fs_1.readFileSync)(this.file, "utf8"));
-        }
-        catch {
-            return {};
-        }
-    }
-    save(scenes) {
-        (0, node_fs_1.writeFileSync)(this.file, JSON.stringify(scenes));
+    try {
+      return JSON.parse((0, node_fs_1.readFileSync)(this.file, "utf8"));
+    } catch {
+      return {};
     }
+  }
+  save(scenes) {
+    (0, node_fs_1.writeFileSync)(this.file, JSON.stringify(scenes));
+  }
 }
 exports.SceneStore = SceneStore;
diff --git a/dist/nodes/sacn-in/sacn-in.js b/dist/nodes/sacn-in/sacn-in.js
index 9ca2791..8b35b96 100644
--- a/dist/nodes/sacn-in/sacn-in.js
+++ b/dist/nodes/sacn-in/sacn-in.js
@@ -5,183 +5,182 @@ const dmx_1 = require("../../lib/dmx");
 const network_1 = require("../../lib/network");
 const interfaces_1 = require("../../lib/interfaces");
 class NodeHandler {
-    node;
-    config;
-    data = new Map();
-    sACN;
-    currentUniverse;
-    trigger;
-    interval;
-    scale;
-    keepaliveTimer;
-    constructor(node, config) {
-        this.node = node;
-        this.config = config;
-        this.currentUniverse = config.universe;
-        this.scale = config.values ?? "percent";
-        this.trigger = config.trigger ?? (config.mode === "passthrough" ? "always" : "changes");
-        this.interval = config.interval !== undefined && config.interval > 0 ? config.interval : 1000;
-        const network = (0, network_1.resolveNetworkOptions)(config);
-        const options = {
-            universes: [config.universe],
-            reuseAddr: config.reuseAddress !== undefined ? config.reuseAddress : true,
-            port: network.port,
-        };
-        if (network.iface !== undefined) {
-            options.iface = network.iface;
-        }
-        switch (config.mode) {
-            case "passthrough":
-                this.sACN = new sacn_1.Receiver(options);
-                break;
-            case "htp":
-            case "ltp":
-                options.mode = config.mode.toUpperCase();
-                this.sACN = new sacn_1.unstable_MergingReceiver(options);
-                break;
-            default:
-                throw new Error("[node-red-sacn] None or invalid mode selected.");
-        }
-        this.sACN.on("error", (err) => {
-            this.node.error(err);
-            this.node.status({ fill: "red", shape: "dot", text: err.message || "receiver error" });
-        });
-        this.node.on("close", () => {
-            this.sACN.close();
-            if (this.keepaliveTimer) {
-                clearTimeout(this.keepaliveTimer);
-            }
-            this.data = new Map();
-        });
-        if (config.mode === "passthrough") {
-            this.sACN.on("packet", (packet) => {
-                const { payload, changed } = this.applyFrame(packet.payload, packet.universe);
-                if (this.trigger === "always" || changed) {
-                    this.sendData({
-                        universe: packet.universe,
-                        payload,
-                        sequence: packet.sequence,
-                        source: packet.sourceAddress,
-                        priority: packet.priority,
-                    });
-                }
-            });
+  node;
+  config;
+  data = new Map();
+  sACN;
+  currentUniverse;
+  trigger;
+  interval;
+  scale;
+  keepaliveTimer;
+  constructor(node, config) {
+    this.node = node;
+    this.config = config;
+    this.currentUniverse = config.universe;
+    this.scale = config.values ?? "percent";
+    this.trigger = config.trigger ?? (config.mode === "passthrough" ? "always" : "changes");
+    this.interval = config.interval !== undefined && config.interval > 0 ? config.interval : 1000;
+    const network = (0, network_1.resolveNetworkOptions)(config);
+    const options = {
+      universes: [config.universe],
+      reuseAddr: config.reuseAddress !== undefined ? config.reuseAddress : true,
+      port: network.port,
+    };
+    if (network.iface !== undefined) {
+      options.iface = network.iface;
+    }
+    switch (config.mode) {
+      case "passthrough":
+        this.sACN = new sacn_1.Receiver(options);
+        break;
+      case "htp":
+      case "ltp":
+        options.mode = config.mode.toUpperCase();
+        this.sACN = new sacn_1.unstable_MergingReceiver(options);
+        break;
+      default:
+        throw new Error("[node-red-sacn] None or invalid mode selected.");
+    }
+    this.sACN.on("error", (err) => {
+      this.node.error(err);
+      this.node.status({ fill: "red", shape: "dot", text: err.message || "receiver error" });
+    });
+    this.node.on("close", () => {
+      this.sACN.close();
+      if (this.keepaliveTimer) {
+        clearTimeout(this.keepaliveTimer);
+      }
+      this.data = new Map();
+    });
+    if (config.mode === "passthrough") {
+      this.sACN.on("packet", (packet) => {
+        const { payload, changed } = this.applyFrame(packet.payload, packet.universe);
+        if (this.trigger === "always" || changed) {
+          this.sendData({
+            universe: packet.universe,
+            payload,
+            sequence: packet.sequence,
+            source: packet.sourceAddress,
+            priority: packet.priority,
+          });
         }
-        else {
-            this.sACN.on("changed", (data) => {
-                const { payload } = this.applyFrame(data.payload, data.universe);
-                if (this.trigger !== "always") {
-                    this.sendData({
-                        universe: data.universe,
-                        payload,
-                    });
-                }
-            });
-            if (this.trigger === "always") {
-                this.sACN.on("packet", () => {
-                    this.emitFull(this.currentUniverse);
-                });
-            }
+      });
+    } else {
+      this.sACN.on("changed", (data) => {
+        const { payload } = this.applyFrame(data.payload, data.universe);
+        if (this.trigger !== "always") {
+          this.sendData({
+            universe: data.universe,
+            payload,
+          });
         }
-        this.node.on("input", (msg) => {
-            this.handleUniverseChange(msg);
+      });
+      if (this.trigger === "always") {
+        this.sACN.on("packet", () => {
+          this.emitFull(this.currentUniverse);
         });
-        this.setStatus();
-        this.resetKeepalive();
+      }
     }
-    setStatus() {
-        this.node.status({
-            fill: "green",
-            shape: "dot",
-            text: `Universe ${this.currentUniverse}`,
-        });
+    this.node.on("input", (msg) => {
+      this.handleUniverseChange(msg);
+    });
+    this.setStatus();
+    this.resetKeepalive();
+  }
+  setStatus() {
+    this.node.status({
+      fill: "green",
+      shape: "dot",
+      text: `Universe ${this.currentUniverse}`,
+    });
+  }
+  parseUniverse(value) {
+    const universe = typeof value === "string" ? parseInt(value, 10) : value;
+    if (typeof universe !== "number" || !Number.isInteger(universe) || universe < 1 || universe > 63999) {
+      return undefined;
     }
-    parseUniverse(value) {
-        const universe = typeof value === "string" ? parseInt(value, 10) : value;
-        if (typeof universe !== "number" || !Number.isInteger(universe) || universe < 1 || universe > 63999) {
-            return undefined;
-        }
-        return universe;
+    return universe;
+  }
+  handleUniverseChange(msg) {
+    const universe = this.parseUniverse(msg.universe);
+    if (universe === undefined) {
+      this.node.warn(
+        `The given "universe"-property "${msg.universe}" (${typeof msg.universe}) is invalid or not between 1 and 63999.`,
+      );
+      return;
     }
-    handleUniverseChange(msg) {
-        const universe = this.parseUniverse(msg.universe);
-        if (universe === undefined) {
-            this.node.warn(`The given "universe"-property "${msg.universe}" (${typeof msg.universe}) is invalid or not between 1 and 63999.`);
-            return;
-        }
-        if (universe === this.currentUniverse) {
-            return;
-        }
-        this.sACN.removeUniverse(this.currentUniverse);
-        this.sACN.addUniverse(universe);
-        this.data?.delete(this.currentUniverse);
-        this.currentUniverse = universe;
-        this.setStatus();
-        if (this.config.clearOnUniverseChange) {
-            this.data?.set(universe, (0, dmx_1.nulledUniverse)());
-            this.emitFull(universe);
-        }
-        else {
-            this.resetKeepalive();
-        }
+    if (universe === this.currentUniverse) {
+      return;
     }
-    applyFrame(incoming, universe) {
-        const previous = this.data?.get(universe);
-        const full = (0, dmx_1.nulledUniverse)();
-        Object.keys(incoming).forEach((key) => {
-            const ch = parseInt(key, 10);
-            if (ch >= 1 && ch <= 512) {
-                full[ch] = (0, dmx_1.fromPercent)(incoming[ch], this.scale);
-            }
-        });
-        let changed = false;
-        const changes = {};
-        for (let ch = 1; ch <= 512; ch++) {
-            const before = previous ? previous[ch] : 0;
-            if (before !== full[ch]) {
-                changed = true;
-                changes[ch] = full[ch];
-            }
-        }
-        this.data?.set(universe, full);
-        const payload = this.config.output === "changes" ? changes : full;
-        return { payload, changed };
+    this.sACN.removeUniverse(this.currentUniverse);
+    this.sACN.addUniverse(universe);
+    this.data?.delete(this.currentUniverse);
+    this.currentUniverse = universe;
+    this.setStatus();
+    if (this.config.clearOnUniverseChange) {
+      this.data?.set(universe, (0, dmx_1.nulledUniverse)());
+      this.emitFull(universe);
+    } else {
+      this.resetKeepalive();
     }
-    sendData(msg) {
-        if (msg.payload && typeof msg.payload === "object") {
-            msg = { ...msg, payload: { ...msg.payload } };
-        }
-        this.node.send(msg);
-        this.resetKeepalive();
+  }
+  applyFrame(incoming, universe) {
+    const previous = this.data?.get(universe);
+    const full = (0, dmx_1.nulledUniverse)();
+    Object.keys(incoming).forEach((key) => {
+      const ch = parseInt(key, 10);
+      if (ch >= 1 && ch <= 512) {
+        full[ch] = (0, dmx_1.fromPercent)(incoming[ch], this.scale);
+      }
+    });
+    let changed = false;
+    const changes = {};
+    for (let ch = 1; ch <= 512; ch++) {
+      const before = previous ? previous[ch] : 0;
+      if (before !== full[ch]) {
+        changed = true;
+        changes[ch] = full[ch];
+      }
     }
-    emitFull(universe) {
-        const full = this.data?.get(universe) ?? (0, dmx_1.nulledUniverse)();
-        this.sendData({ universe, payload: full });
+    this.data?.set(universe, full);
+    const payload = this.config.output === "changes" ? changes : full;
+    return { payload, changed };
+  }
+  sendData(msg) {
+    if (msg.payload && typeof msg.payload === "object") {
+      msg = { ...msg, payload: { ...msg.payload } };
     }
-    resetKeepalive() {
-        if (this.trigger !== "interval") {
-            return;
-        }
-        if (this.keepaliveTimer) {
-            clearTimeout(this.keepaliveTimer);
-        }
-        this.keepaliveTimer = setTimeout(() => {
-            this.keepaliveTick();
-        }, this.interval);
+    this.node.send(msg);
+    this.resetKeepalive();
+  }
+  emitFull(universe) {
+    const full = this.data?.get(universe) ?? (0, dmx_1.nulledUniverse)();
+    this.sendData({ universe, payload: full });
+  }
+  resetKeepalive() {
+    if (this.trigger !== "interval") {
+      return;
     }
-    keepaliveTick() {
-        if (this.data?.has(this.currentUniverse)) {
-            this.emitFull(this.currentUniverse);
-        }
-        else {
-            this.resetKeepalive();
-        }
+    if (this.keepaliveTimer) {
+      clearTimeout(this.keepaliveTimer);
+    }
+    this.keepaliveTimer = setTimeout(() => {
+      this.keepaliveTick();
+    }, this.interval);
+  }
+  keepaliveTick() {
+    if (this.data?.has(this.currentUniverse)) {
+      this.emitFull(this.currentUniverse);
+    } else {
+      this.resetKeepalive();
     }
+  }
 }
 exports.default = (RED) => {
-    (0, interfaces_1.registerInterfaceEndpoint)(RED);
-    RED.nodes.registerType("sacn-in", function (config) {
-        RED.nodes.createNode(this, config);
-        new NodeHandler(this, config);
-    });
+  (0, interfaces_1.registerInterfaceEndpoint)(RED);
+  RED.nodes.registerType("sacn-in", function (config) {
+    RED.nodes.createNode(this, config);
+    new NodeHandler(this, config);
+  });
 };
diff --git a/dist/nodes/sacn-out/sacn-out.js b/dist/nodes/sacn-out/sacn-out.js
index da96859..0db05b5 100644
--- a/dist/nodes/sacn-out/sacn-out.js
+++ b/dist/nodes/sacn-out/sacn-out.js
@@ -5,80 +5,79 @@ const dmx_1 = require("../../lib/dmx");
 const network_1 = require("../../lib/network");
 const interfaces_1 = require("../../lib/interfaces");
 class NodeHandler {
-    node;
-    config;
-    sACN;
-    options;
-    constructor(node, config) {
-        this.node = node;
-        this.config = config;
-        const network = (0, network_1.resolveNetworkOptions)(config);
-        this.options = {
-            universe: config.universe,
-            reuseAddr: config.reuseAddress !== undefined ? config.reuseAddress : true,
-            minRefreshRate: config.speed !== undefined ? config.speed : 0,
-            port: network.port,
-            defaultPacketOptions: {
-                useRawDmxValues: (config.values ?? "percent") === "absolute",
-            },
-        };
-        if (network.iface !== undefined) {
-            this.options.iface = network.iface;
-        }
-        this.sACN = new sacn_1.Sender(this.options);
-        this.sACN.on("error", (err) => {
-            this.node.error(err);
-            this.node.status({ fill: "red", shape: "dot", text: err.message || "sender error" });
-        });
-        this.node.on("close", (done) => {
-            const shutdown = () => {
-                this.sACN.close();
-                done();
-            };
-            if (this.config.blankOnClose) {
-                this.sACN
-                    .send({
-                    payload: (0, dmx_1.nulledUniverse)(),
-                    sourceName: config.sourceName,
-                    priority: config.priority || 100,
-                })
-                    .then(shutdown)
-                    .catch(shutdown);
-            }
-            else {
-                shutdown();
-            }
-        });
-        this.node.on("input", (msg) => {
-            this.sACN
-                .send({
-                payload: msg.payload,
-                sourceName: config.sourceName,
-                priority: config.priority || 100,
-            })
-                .then(() => {
-                this.setStatus();
-            })
-                .catch((err) => {
-                this.node.error(err, msg);
-                this.node.status({ fill: "red", shape: "dot", text: err.message || "send failed" });
-            });
-        });
-        this.setStatus();
+  node;
+  config;
+  sACN;
+  options;
+  constructor(node, config) {
+    this.node = node;
+    this.config = config;
+    const network = (0, network_1.resolveNetworkOptions)(config);
+    this.options = {
+      universe: config.universe,
+      reuseAddr: config.reuseAddress !== undefined ? config.reuseAddress : true,
+      minRefreshRate: config.speed !== undefined ? config.speed : 0,
+      port: network.port,
+      defaultPacketOptions: {
+        useRawDmxValues: (config.values ?? "percent") === "absolute",
+      },
+    };
+    if (network.iface !== undefined) {
+      this.options.iface = network.iface;
     }
-    setStatus() {
-        const rate = this.config.speed !== undefined && this.config.speed > 0 ? `${this.config.speed} Hz` : "once";
-        this.node.status({
-            fill: "green",
-            shape: "dot",
-            text: `Universe ${this.config.universe} · ${rate}`,
+    this.sACN = new sacn_1.Sender(this.options);
+    this.sACN.on("error", (err) => {
+      this.node.error(err);
+      this.node.status({ fill: "red", shape: "dot", text: err.message || "sender error" });
+    });
+    this.node.on("close", (done) => {
+      const shutdown = () => {
+        this.sACN.close();
+        done();
+      };
+      if (this.config.blankOnClose) {
+        this.sACN
+          .send({
+            payload: (0, dmx_1.nulledUniverse)(),
+            sourceName: config.sourceName,
+            priority: config.priority || 100,
+          })
+          .then(shutdown)
+          .catch(shutdown);
+      } else {
+        shutdown();
+      }
+    });
+    this.node.on("input", (msg) => {
+      this.sACN
+        .send({
+          payload: msg.payload,
+          sourceName: config.sourceName,
+          priority: config.priority || 100,
+        })
+        .then(() => {
+          this.setStatus();
+        })
+        .catch((err) => {
+          this.node.error(err, msg);
+          this.node.status({ fill: "red", shape: "dot", text: err.message || "send failed" });
         });
-    }
+    });
+    this.setStatus();
+  }
+  setStatus() {
+    const rate = this.config.speed !== undefined && this.config.speed > 0 ? `${this.config.speed} Hz` : "once";
+    this.node.status({
+      fill: "green",
+      shape: "dot",
+      text: `Universe ${this.config.universe} · ${rate}`,
+    });
+  }
 }
 exports.default = (RED) => {
-    (0, interfaces_1.registerInterfaceEndpoint)(RED);
-    RED.nodes.registerType("sacn-out", function (config) {
-        RED.nodes.createNode(this, config);
-        new NodeHandler(this, config);
-    });
+  (0, interfaces_1.registerInterfaceEndpoint)(RED);
+  RED.nodes.registerType("sacn-out", function (config) {
+    RED.nodes.createNode(this, config);
+    new NodeHandler(this, config);
+  });
 };
diff --git a/dist/nodes/scene-controller/locales/de/scene-controller.json b/dist/nodes/scene-controller/locales/de/scene-controller.json
index dbd233b..d4702f5 100644
--- a/dist/nodes/scene-controller/locales/de/scene-controller.json
+++ b/dist/nodes/scene-controller/locales/de/scene-controller.json
@@ -3,7 +3,11 @@
     "label": {
       "values": "Werte",
       "values_percent": "Prozent (0–100)",
-      "values_absolute": "Absolut (0–255)"
+      "values_absolute": "Absolut (0–255)",
+      "playMode": "Wiedergabe",
+      "playMode_switch": "Umschalten (neue Szene ersetzt)",
+      "playMode_add": "Addieren (Szenen stapeln, HTP)",
+      "blackoutOnStop": "Beim Stoppen Nullwerte senden"
     }
   }
 }
\ No newline at end of file
diff --git a/dist/nodes/scene-controller/locales/en-US/scene-controller.json b/dist/nodes/scene-controller/locales/en-US/scene-controller.json
index 579358a..7d1498c 100644
--- a/dist/nodes/scene-controller/locales/en-US/scene-controller.json
+++ b/dist/nodes/scene-controller/locales/en-US/scene-controller.json
@@ -3,7 +3,11 @@
     "label": {
       "values": "values",
       "values_percent": "percent (0–100)",
-      "values_absolute": "absolute (0–255)"
+      "values_absolute": "absolute (0–255)",
+      "playMode": "Playback",
+      "playMode_switch": "Switch (new scene replaces)",
+      "playMode_add": "Add (stack scenes, HTP)",
+      "blackoutOnStop": "Send zero values on stop"
     }
   }
 }
\ No newline at end of file
diff --git a/dist/nodes/scene-controller/scene-controller.html b/dist/nodes/scene-controller/scene-controller.html
index 812dccd..d287419 100644
--- a/dist/nodes/scene-controller/scene-controller.html
+++ b/dist/nodes/scene-controller/scene-controller.html
@@ -16,6 +16,23 @@
             <option value="absolute" data-i18n="scene-controller.label.values_absolute"></option>
         </select>
     </div>
+    <div class="form-row">
+        <label for="node-input-playMode">
+            <i class="fa fa-layer-group"></i>
+            <span data-i18n="scene-controller.label.playMode"></span>
+        </label>
+        <select id="node-input-playMode" style="width:70%;">
+            <option value="switch" selected data-i18n="scene-controller.label.playMode_switch"></option>
+            <option value="add" data-i18n="scene-controller.label.playMode_add"></option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-blackoutOnStop" style="width:auto;">
+            <i class="fa fa-power-off"></i>
+            <span data-i18n="scene-controller.label.blackoutOnStop"></span>
+        </label>
+        <input type="checkbox" id="node-input-blackoutOnStop" style="display:inline-block; width:auto; vertical-align:top;">
+    </div>
 </script>
 <script type="text/html" data-help-name="scene-controller">
     <p>Records DMX scenes and plays them back later.</p>
@@ -28,6 +45,8 @@ <h3>Details</h3>
     <ul>
         <li><code>save</code> - store the <code>payload</code> as the given scene.</li>
         <li><code>play</code> - emit a previously saved scene.</li>
+        <li><code>stop</code> - stop emitting the given scene but keep it stored. If the <b>Send zero values on stop</b>
+            option is enabled and no other scene remains active, a nulled universe is emitted once.</li>
         <li><code>reset</code> - clear the given scene (or all scenes) and, if it is currently playing, emit a nulled universe.</li>
     </ul>
     <p>
@@ -35,12 +54,19 @@ <h3>Details</h3>
         The accepted value range follows the <b>Values</b> setting: a percentage (<code>0</code>–<code>100</code>)
         or raw DMX values (<code>0</code>–<code>255</code>).
     </p>
+    <p>
+        The <b>Playback</b> setting controls what happens when <code>play</code> is triggered while another scene is
+        already active. In <b>Switch</b> mode the new scene replaces the running look. In <b>Add</b> mode scenes are
+        stacked and combined per channel by HTP (highest value wins); <code>stop</code> or <code>reset</code> of a single
+        scene then re-emits the remaining combined look. Only when the last active scene is stopped or reset does the
+        output go dark.
+    </p>
     <h3>Inputs</h3>
     <dl class="message-properties">
         <dt>action <span class="property-type">string</span></dt>
-        <dd>Operation to perform: <code>save</code>, <code>play</code> or <code>reset</code>.</dd>
+        <dd>Operation to perform: <code>save</code>, <code>play</code>, <code>stop</code> or <code>reset</code>.</dd>
         <dt>scene <span class="property-type">number</span></dt>
-        <dd>The scene to save or play. Required for <code>save</code> and <code>play</code>; optional for <code>reset</code> (omit to reset all scenes).</dd>
+        <dd>The scene to save, play or stop. Required for <code>save</code>, <code>play</code> and <code>stop</code>; optional for <code>reset</code> (omit to reset all scenes).</dd>
         <dt class="optional">universe <span class="property-type">number</span></dt>
         <dd>The universe the payload belongs to. Required when a single universe is provided as an array or a flat value object.</dd>
         <dt>payload <span class="property-type">array | object</span></dt>
@@ -61,6 +87,8 @@ <h4>Single universe</h4>
         <dd>The scene that is played.</dd>
         <dt class="optional">reset <span class="property-type">boolean</span></dt>
         <dd>Present and <code>true</code> for a reset message; otherwise absent.</dd>
+        <dt class="optional">stopped <span class="property-type">boolean</span></dt>
+        <dd>Present and <code>true</code> for the nulled message emitted on <code>stop</code>; otherwise absent.</dd>
     </dl>
     <h4>Multiple universes</h4>
     <dl class="message-properties">
@@ -72,6 +100,8 @@ <h4>Multiple universes</h4>
         <dd>The scene that is played.</dd>
         <dt class="optional">reset <span class="property-type">boolean</span></dt>
         <dd>Present and <code>true</code> for a reset message; otherwise absent.</dd>
+        <dt class="optional">stopped <span class="property-type">boolean</span></dt>
+        <dd>Present and <code>true</code> for the nulled message emitted on <code>stop</code>; otherwise absent.</dd>
     </dl>
     <h3>References</h3>
     <ul>
@@ -91,6 +121,13 @@ <h3>References</h3>
                     value: "percent",
                     required: true,
                 },
+                playMode: {
+                    value: "switch",
+                    required: true,
+                },
+                blackoutOnStop: {
+                    value: false,
+                },
             },
             inputs: 1,
             outputs: 1,
diff --git a/dist/nodes/scene-controller/scene-controller.js b/dist/nodes/scene-controller/scene-controller.js
index 3644c1a..14200c2 100644
--- a/dist/nodes/scene-controller/scene-controller.js
+++ b/dist/nodes/scene-controller/scene-controller.js
@@ -3,290 +3,360 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const dmx_1 = require("../../lib/dmx");
 const scene_store_1 = require("../../lib/scene-store");
 class NodeHandler {
-    node;
-    config;
-    scale;
-    store;
-    scenes;
-    playingScene = null;
-    constructor(node, config, store) {
-        this.node = node;
-        this.config = config;
-        this.scale = config.values ?? "percent";
-        this.store = store;
-        this.scenes = store.load();
-        this.node.on("input", (msg) => {
-            const message = msg;
-            switch (message.action || "undefined") {
-                case "save":
-                    if (this.validateSave(message)) {
-                        this.handleSave(message);
-                    }
-                    break;
-                case "play":
-                    if (this.validatePlay(message)) {
-                        this.handlePlay(message);
-                    }
-                    break;
-                case "reset":
-                    if (this.validateReset(message)) {
-                        this.handleReset(message);
-                    }
-                    break;
-                default:
-                    if (message.action === undefined) {
-                        this.node.warn('Message-Object is missing the "action"-property.');
-                        break;
-                    }
-                    this.node.warn(`The given "action"-property "${message.action}" (${typeof message.action}) is not supported.`);
-                    break;
-            }
-        });
+  node;
+  config;
+  scale;
+  store;
+  scenes;
+  playMode;
+  activeScenes = new Set();
+  constructor(node, config, store) {
+    this.node = node;
+    this.config = config;
+    this.scale = config.values ?? "percent";
+    this.store = store;
+    this.scenes = store.load();
+    this.playMode = config.playMode ?? "switch";
+    this.node.on("input", (msg) => {
+      const message = msg;
+      switch (message.action || "undefined") {
+        case "save":
+          if (this.validateSave(message)) {
+            this.handleSave(message);
+          }
+          break;
+        case "play":
+          if (this.validatePlay(message)) {
+            this.handlePlay(message);
+          }
+          break;
+        case "stop":
+          if (this.validateStop(message)) {
+            this.handleStop(message);
+          }
+          break;
+        case "reset":
+          if (this.validateReset(message)) {
+            this.handleReset(message);
+          }
+          break;
+        default:
+          if (message.action === undefined) {
+            this.node.warn('Message-Object is missing the "action"-property.');
+            break;
+          }
+          this.node.warn(
+            `The given "action"-property "${message.action}" (${typeof message.action}) is not supported.`,
+          );
+          break;
+      }
+    });
+  }
+  validateUniverse(universe) {
+    if (universe === undefined || isNaN(universe) || universe < 1 || universe > 63999) {
+      throw new Error(`The universe number '${universe}' (${typeof universe}) is invalid or not between 1 and 63999.`);
     }
-    validateUniverse(universe) {
-        if (universe === undefined || isNaN(universe) || universe < 1 || universe > 63999) {
-            throw new Error(`The universe number '${universe}' (${typeof universe}) is invalid or not between 1 and 63999.`);
-        }
+  }
+  validateChannel(channel, universe, firstChannel = 1, lastChannel = 512) {
+    if (isNaN(channel) || channel < firstChannel || channel > lastChannel) {
+      throw new Error(
+        `Channel number '${channel}' (${typeof channel}) of universe '${universe}' is invalid or not between ${firstChannel} and ${lastChannel}.`,
+      );
     }
-    validateChannel(channel, universe, firstChannel = 1, lastChannel = 512) {
-        if (isNaN(channel) || channel < firstChannel || channel > lastChannel) {
-            throw new Error(`Channel number '${channel}' (${typeof channel}) of universe '${universe}' is invalid or not between ${firstChannel} and ${lastChannel}.`);
-        }
+  }
+  validateValue(value, channel, universe) {
+    const max = (0, dmx_1.maxValue)(this.scale);
+    if (isNaN(value) || value < 0 || value > max) {
+      throw new Error(
+        `Value '${value}' (${typeof value}) for channel '${channel}' of universe '${universe}' is invalid or not between 0 and ${max}.`,
+      );
     }
-    validateValue(value, channel, universe) {
-        const max = (0, dmx_1.maxValue)(this.scale);
-        if (isNaN(value) || value < 0 || value > max) {
-            throw new Error(`Value '${value}' (${typeof value}) for channel '${channel}' of universe '${universe}' is invalid or not between 0 and ${max}.`);
-        }
+  }
+  parseUniverseObject(input, universe) {
+    const keys = Object.keys(input);
+    const output = {};
+    const startIndex = keys.includes("0") || keys.includes(0) ? 0 : 1;
+    const endIndex = startIndex === 0 ? 511 : 512;
+    if (keys.length !== 512) {
+      throw new Error(`Universe ${universe} contains ${keys.length} values, but not 512 values.`);
     }
-    parseUniverseObject(input, universe) {
-        const keys = Object.keys(input);
-        const output = {};
-        const startIndex = keys.includes("0") || keys.includes(0) ? 0 : 1;
-        const endIndex = startIndex === 0 ? 511 : 512;
-        if (keys.length !== 512) {
-            throw new Error(`Universe ${universe} contains ${keys.length} values, but not 512 values.`);
-        }
-        let channel;
-        for (channel in input) {
-            let value = input[channel];
-            if (typeof channel === "string") {
-                channel = parseInt(channel, 10);
-            }
-            this.validateChannel(channel, universe, startIndex, endIndex);
-            if (typeof value === "string") {
-                value = parseFloat(value);
-            }
-            this.validateValue(value, channel, universe);
-            output[channel] = value;
-        }
-        return output;
+    let channel;
+    for (channel in input) {
+      let value = input[channel];
+      if (typeof channel === "string") {
+        channel = parseInt(channel, 10);
+      }
+      this.validateChannel(channel, universe, startIndex, endIndex);
+      if (typeof value === "string") {
+        value = parseFloat(value);
+      }
+      this.validateValue(value, channel, universe);
+      output[channel] = value;
     }
-    parseUniverseArray(input, universe) {
-        const output = {};
-        if (input.length !== 512) {
-            throw new Error(`Universe ${universe} contains ${input.length} values, but not 512 values.`);
-        }
-        input.forEach((value, channel) => {
-            this.validateChannel(channel, universe, 0, 511);
-            if (typeof value === "string") {
-                value = parseFloat(value);
-            }
-            this.validateValue(value, channel, universe);
-            output[channel] = value;
-        });
-        return output;
+    return output;
+  }
+  parseUniverseArray(input, universe) {
+    const output = {};
+    if (input.length !== 512) {
+      throw new Error(`Universe ${universe} contains ${input.length} values, but not 512 values.`);
     }
-    parseUniverseData(input, universe) {
-        const output = {};
-        if (input === undefined || input === null || (typeof input !== "object" && !Array.isArray(input))) {
-            throw new Error(`Payload must be an object or an array. Type "${typeof input}" is not supported.`);
+    input.forEach((value, channel) => {
+      this.validateChannel(channel, universe, 0, 511);
+      if (typeof value === "string") {
+        value = parseFloat(value);
+      }
+      this.validateValue(value, channel, universe);
+      output[channel] = value;
+    });
+    return output;
+  }
+  parseUniverseData(input, universe) {
+    const output = {};
+    if (input === undefined || input === null || (typeof input !== "object" && !Array.isArray(input))) {
+      throw new Error(`Payload must be an object or an array. Type "${typeof input}" is not supported.`);
+    }
+    if (Array.isArray(input)) {
+      if (typeof universe === "string") {
+        universe = parseInt(universe, 10);
+      }
+      this.validateUniverse(universe);
+      output[universe] = this.parseUniverseArray(input, universe);
+    } else if (typeof input === "object") {
+      let containsPossibleNumericValues = false;
+      let containsPossibleUniverses = false;
+      let containsDifferent = false;
+      for (const key in input) {
+        const item = input[key];
+        if (typeof item === "string" || !isNaN(item)) {
+          containsPossibleNumericValues = true;
+        } else if (Array.isArray(item) || typeof item === "object") {
+          containsPossibleUniverses = true;
+        } else {
+          containsDifferent = true;
         }
-        if (Array.isArray(input)) {
-            if (typeof universe === "string") {
-                universe = parseInt(universe, 10);
-            }
-            this.validateUniverse(universe);
-            output[universe] = this.parseUniverseArray(input, universe);
+      }
+      if (containsDifferent) {
+        throw new Error("Payload contains invalid data.");
+      }
+      if (containsPossibleUniverses && containsPossibleNumericValues) {
+        throw new Error("Payload contains objects or arrays parallel to numeric values");
+      }
+      if (containsPossibleNumericValues) {
+        if (typeof universe === "string") {
+          universe = parseInt(universe, 10);
         }
-        else if (typeof input === "object") {
-            let containsPossibleNumericValues = false;
-            let containsPossibleUniverses = false;
-            let containsDifferent = false;
-            for (const key in input) {
-                const item = input[key];
-                if (typeof item === "string" || !isNaN(item)) {
-                    containsPossibleNumericValues = true;
-                }
-                else if (Array.isArray(item) || typeof item === "object") {
-                    containsPossibleUniverses = true;
-                }
-                else {
-                    containsDifferent = true;
-                }
-            }
-            if (containsDifferent) {
-                throw new Error("Payload contains invalid data.");
-            }
-            if (containsPossibleUniverses && containsPossibleNumericValues) {
-                throw new Error("Payload contains objects or arrays parallel to numeric values");
-            }
-            if (containsPossibleNumericValues) {
-                if (typeof universe === "string") {
-                    universe = parseInt(universe, 10);
-                }
-                this.validateUniverse(universe);
-                output[universe] = this.parseUniverseObject(input, universe);
-            }
-            else if (containsPossibleUniverses) {
-                let key;
-                for (key in input) {
-                    if (typeof key === "string") {
-                        key = parseInt(key, 10);
-                    }
-                    this.validateUniverse(key);
-                    const item = input[key];
-                    if (Array.isArray(item)) {
-                        output[key] = this.parseUniverseArray(item, key);
-                    }
-                    else if (typeof item === "object") {
-                        output[key] = this.parseUniverseObject(item, key);
-                    }
-                    else {
-                        throw new Error(`Data for universe ${key} is invalid.`);
-                    }
-                }
-            }
+        this.validateUniverse(universe);
+        output[universe] = this.parseUniverseObject(input, universe);
+      } else if (containsPossibleUniverses) {
+        let key;
+        for (key in input) {
+          if (typeof key === "string") {
+            key = parseInt(key, 10);
+          }
+          this.validateUniverse(key);
+          const item = input[key];
+          if (Array.isArray(item)) {
+            output[key] = this.parseUniverseArray(item, key);
+          } else if (typeof item === "object") {
+            output[key] = this.parseUniverseObject(item, key);
+          } else {
+            throw new Error(`Data for universe ${key} is invalid.`);
+          }
         }
-        return output;
+      }
     }
-    validateScene(message) {
-        if (message.scene === undefined) {
-            this.node.warn('Message-Object is missing the "scene"-property.');
-            return false;
-        }
-        if (isNaN(message.scene)) {
-            this.node.warn(`The given "scene"-property "${message.scene}" (${typeof message.scene}) is not a positive number.`);
-            return false;
-        }
-        return true;
+    return output;
+  }
+  validateScene(message) {
+    if (message.scene === undefined) {
+      this.node.warn('Message-Object is missing the "scene"-property.');
+      return false;
     }
-    validateSave(message) {
-        if (!this.validateScene(message)) {
-            return false;
-        }
-        if (typeof message.payload !== "object" && !Array.isArray(message.payload)) {
-            this.node.warn("The given payload has to be an object or array.");
-            return false;
-        }
-        try {
-            message.payload = this.parseUniverseData(message.payload, message.universe);
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                this.node.warn(e.message);
-            }
-            return false;
-        }
-        return true;
+    if (isNaN(message.scene)) {
+      this.node.warn(
+        `The given "scene"-property "${message.scene}" (${typeof message.scene}) is not a positive number.`,
+      );
+      return false;
     }
-    validatePlay(message) {
-        if (!this.validateScene(message)) {
-            return false;
-        }
-        return true;
+    return true;
+  }
+  validateSave(message) {
+    if (!this.validateScene(message)) {
+      return false;
     }
-    validateReset(_) {
-        return true;
+    if (typeof message.payload !== "object" && !Array.isArray(message.payload)) {
+      this.node.warn("The given payload has to be an object or array.");
+      return false;
     }
-    handleSave(message) {
-        this.scenes[message.scene] = {
-            scene: message.scene,
-            data: message.payload,
-        };
-        this.store.save(this.scenes);
+    try {
+      message.payload = this.parseUniverseData(message.payload, message.universe);
+    } catch (e) {
+      if (e instanceof Error) {
+        this.node.warn(e.message);
+      }
+      return false;
     }
-    handlePlay(message) {
-        const data = this.scenes[message.scene];
-        if (!data) {
-            this.node.warn(`Cannot play scene no. ${message.scene} since it has not been recorded yet.`);
-            return;
-        }
-        this.playingScene = message.scene;
-        let payload;
-        let universe = undefined;
-        const universes = Object.keys(data.data);
-        if (universes.length === 1) {
-            universe = parseInt(universes[0], 10);
-            payload = data.data[universe];
-        }
-        else {
-            payload = data.data;
+    return true;
+  }
+  validatePlay(message) {
+    if (!this.validateScene(message)) {
+      return false;
+    }
+    return true;
+  }
+  validateStop(message) {
+    if (!this.validateScene(message)) {
+      return false;
+    }
+    return true;
+  }
+  validateReset(_) {
+    return true;
+  }
+  handleSave(message) {
+    this.scenes[message.scene] = {
+      scene: message.scene,
+      data: message.payload,
+    };
+    this.store.save(this.scenes);
+  }
+  mergeActiveScenes() {
+    const combined = {};
+    for (const id of this.activeScenes) {
+      const scene = this.scenes[id];
+      if (!scene) {
+        continue;
+      }
+      for (const universeKey of Object.keys(scene.data)) {
+        const universe = parseInt(universeKey, 10);
+        const channels = scene.data[universe];
+        const target = combined[universe] ?? (combined[universe] = {});
+        for (const channelKey of Object.keys(channels)) {
+          const channel = parseInt(channelKey, 10);
+          target[channel] = Math.max(target[channel] ?? 0, channels[channel]);
         }
+      }
+    }
+    return combined;
+  }
+  shapeOutput(universes) {
+    const keys = Object.keys(universes);
+    if (keys.length === 1) {
+      const universe = parseInt(keys[0], 10);
+      return { payload: universes[universe], universe };
+    }
+    return { payload: universes, universe: undefined };
+  }
+  buildBlackout(data) {
+    const universes = Object.keys(data);
+    if (universes.length === 1) {
+      return { payload: (0, dmx_1.nulledUniverse)(), universe: parseInt(universes[0], 10) };
+    }
+    const payload = {};
+    universes.forEach((universe) => {
+      payload[parseInt(universe, 10)] = (0, dmx_1.nulledUniverse)();
+    });
+    return { payload, universe: undefined };
+  }
+  emitActiveLook(scene, topic) {
+    const { payload, universe } = this.shapeOutput(this.mergeActiveScenes());
+    const count = this.activeScenes.size;
+    const label = count === 1 ? (topic ?? `Scene ${scene}`) : `${count} scenes`;
+    const out = {
+      topic: topic ?? label,
+      scene: scene,
+      payload: payload,
+      universe: universe,
+    };
+    this.node.send(out);
+    this.node.status({
+      fill: "green",
+      shape: "dot",
+      text: label,
+    });
+  }
+  standby() {
+    this.node.status({
+      fill: "green",
+      shape: "ring",
+      text: "Standby",
+    });
+  }
+  handlePlay(message) {
+    const data = this.scenes[message.scene];
+    if (!data) {
+      this.node.warn(`Cannot play scene no. ${message.scene} since it has not been recorded yet.`);
+      return;
+    }
+    if (this.playMode === "switch") {
+      this.activeScenes = new Set([message.scene]);
+    } else {
+      this.activeScenes.add(message.scene);
+    }
+    this.emitActiveLook(message.scene, message.topic);
+  }
+  handleStop(message) {
+    if (!this.activeScenes.has(message.scene)) {
+      return;
+    }
+    const stopped = this.scenes[message.scene];
+    this.activeScenes.delete(message.scene);
+    if (this.activeScenes.size === 0) {
+      this.standby();
+      if (this.config.blackoutOnStop && stopped) {
+        const { payload, universe } = this.buildBlackout(stopped.data);
         const out = {
-            topic: message.topic ?? `Scene ${message.scene}`,
-            scene: message.scene,
-            payload: payload,
-            universe: universe,
+          topic: `Scene ${message.scene}`,
+          scene: message.scene,
+          payload: payload,
+          universe: universe,
+          stopped: true,
         };
         this.node.send(out);
-        this.node.status({
-            fill: "green",
-            shape: "dot",
-            text: message.topic ?? `Scene ${message.scene}`,
-        });
+      }
+      return;
     }
-    handleReset(message) {
-        const resetScene = (scene) => {
-            const data = this.scenes[scene];
-            if (this.playingScene === scene) {
-                this.playingScene = null;
-                this.node.status({
-                    fill: "green",
-                    shape: "ring",
-                    text: "Standby",
-                });
-                if (data) {
-                    const universes = Object.keys(data.data);
-                    let universe = undefined;
-                    let payload;
-                    if (universes.length === 1) {
-                        universe = parseInt(universes[0], 10);
-                        payload = (0, dmx_1.nulledUniverse)();
-                    }
-                    else {
-                        payload = {};
-                        universes.forEach((universe) => {
-                            payload[parseInt(universe, 10)] = (0, dmx_1.nulledUniverse)();
-                        });
-                    }
-                    const out = {
-                        topic: `Scene ${scene}`,
-                        scene: scene,
-                        payload: payload,
-                        universe: universe,
-                        reset: true,
-                    };
-                    this.node.send(out);
-                }
-            }
-            delete this.scenes[scene];
-        };
-        if (message.scene) {
-            resetScene(message.scene);
-        }
-        else {
-            Object.keys(this.scenes).forEach((key) => {
-                resetScene(parseInt(key, 10));
-            });
+    this.emitActiveLook(message.scene, message.topic);
+  }
+  handleReset(message) {
+    const resetScene = (scene) => {
+      const data = this.scenes[scene];
+      const wasActive = this.activeScenes.delete(scene);
+      delete this.scenes[scene];
+      if (!wasActive) {
+        return;
+      }
+      if (this.activeScenes.size === 0) {
+        this.standby();
+        if (data) {
+          const { payload, universe } = this.buildBlackout(data.data);
+          const out = {
+            topic: `Scene ${scene}`,
+            scene: scene,
+            payload: payload,
+            universe: universe,
+            reset: true,
+          };
+          this.node.send(out);
         }
-        this.store.save(this.scenes);
+      } else {
+        this.emitActiveLook(scene);
+      }
+    };
+    if (message.scene) {
+      resetScene(message.scene);
+    } else {
+      Object.keys(this.scenes).forEach((key) => {
+        resetScene(parseInt(key, 10));
+      });
     }
+    this.store.save(this.scenes);
+  }
 }
 exports.default = (RED) => {
-    RED.nodes.registerType("scene-controller", function (config) {
-        RED.nodes.createNode(this, config);
-        const baseDir = RED.settings.userDir ?? process.cwd();
-        new NodeHandler(this, config, new scene_store_1.SceneStore(baseDir, this.id));
-    });
+  RED.nodes.registerType("scene-controller", function (config) {
+    RED.nodes.createNode(this, config);
+    const baseDir = RED.settings.userDir ?? process.cwd();
+    new NodeHandler(this, config, new scene_store_1.SceneStore(baseDir, this.id));
+  });
 };
diff --git a/src/nodes/scene-controller/docs.html b/src/nodes/scene-controller/docs.html
index 32eeacb..274e926 100644
--- a/src/nodes/scene-controller/docs.html
+++ b/src/nodes/scene-controller/docs.html
@@ -9,6 +9,8 @@ <h3>Details</h3>
 <ul>
     <li><code>save</code> - store the <code>payload</code> as the given scene.</li>
     <li><code>play</code> - emit a previously saved scene.</li>
+    <li><code>stop</code> - stop emitting the given scene but keep it stored. If the <b>Send zero values on stop</b>
+        option is enabled and no other scene remains active, a nulled universe is emitted once.</li>
     <li><code>reset</code> - clear the given scene (or all scenes) and, if it is currently playing, emit a nulled universe.</li>
 </ul>
 <p>
@@ -16,13 +18,20 @@ <h3>Details</h3>
     The accepted value range follows the <b>Values</b> setting: a percentage (<code>0</code>–<code>100</code>)
     or raw DMX values (<code>0</code>–<code>255</code>).
 </p>
+<p>
+    The <b>Playback</b> setting controls what happens when <code>play</code> is triggered while another scene is
+    already active. In <b>Switch</b> mode the new scene replaces the running look. In <b>Add</b> mode scenes are
+    stacked and combined per channel by HTP (highest value wins); <code>stop</code> or <code>reset</code> of a single
+    scene then re-emits the remaining combined look. Only when the last active scene is stopped or reset does the
+    output go dark.
+</p>
 
 <h3>Inputs</h3>
 <dl class="message-properties">
     <dt>action <span class="property-type">string</span></dt>
-    <dd>Operation to perform: <code>save</code>, <code>play</code> or <code>reset</code>.</dd>
+    <dd>Operation to perform: <code>save</code>, <code>play</code>, <code>stop</code> or <code>reset</code>.</dd>
     <dt>scene <span class="property-type">number</span></dt>
-    <dd>The scene to save or play. Required for <code>save</code> and <code>play</code>; optional for <code>reset</code> (omit to reset all scenes).</dd>
+    <dd>The scene to save, play or stop. Required for <code>save</code>, <code>play</code> and <code>stop</code>; optional for <code>reset</code> (omit to reset all scenes).</dd>
     <dt class="optional">universe <span class="property-type">number</span></dt>
     <dd>The universe the payload belongs to. Required when a single universe is provided as an array or a flat value object.</dd>
     <dt>payload <span class="property-type">array | object</span></dt>
@@ -44,6 +53,8 @@ <h4>Single universe</h4>
     <dd>The scene that is played.</dd>
     <dt class="optional">reset <span class="property-type">boolean</span></dt>
     <dd>Present and <code>true</code> for a reset message; otherwise absent.</dd>
+    <dt class="optional">stopped <span class="property-type">boolean</span></dt>
+    <dd>Present and <code>true</code> for the nulled message emitted on <code>stop</code>; otherwise absent.</dd>
 </dl>
 
 <h4>Multiple universes</h4>
@@ -56,6 +67,8 @@ <h4>Multiple universes</h4>
     <dd>The scene that is played.</dd>
     <dt class="optional">reset <span class="property-type">boolean</span></dt>
     <dd>Present and <code>true</code> for a reset message; otherwise absent.</dd>
+    <dt class="optional">stopped <span class="property-type">boolean</span></dt>
+    <dd>Present and <code>true</code> for the nulled message emitted on <code>stop</code>; otherwise absent.</dd>
 </dl>
 
 <h3>References</h3>
diff --git a/src/nodes/scene-controller/form.html b/src/nodes/scene-controller/form.html
index d0743dc..aa249bc 100644
--- a/src/nodes/scene-controller/form.html
+++ b/src/nodes/scene-controller/form.html
@@ -14,4 +14,21 @@
         <option value="percent" selected data-i18n="scene-controller.label.values_percent"></option>
         <option value="absolute" data-i18n="scene-controller.label.values_absolute"></option>
     </select>
+</div>
+<div class="form-row">
+    <label for="node-input-playMode">
+        <i class="fa fa-layer-group"></i>
+        <span data-i18n="scene-controller.label.playMode"></span>
+    </label>
+    <select id="node-input-playMode" style="width:70%;">
+        <option value="switch" selected data-i18n="scene-controller.label.playMode_switch"></option>
+        <option value="add" data-i18n="scene-controller.label.playMode_add"></option>
+    </select>
+</div>
+<div class="form-row">
+    <label for="node-input-blackoutOnStop" style="width:auto;">
+        <i class="fa fa-power-off"></i>
+        <span data-i18n="scene-controller.label.blackoutOnStop"></span>
+    </label>
+    <input type="checkbox" id="node-input-blackoutOnStop" style="display:inline-block; width:auto; vertical-align:top;">
 </div>
\ No newline at end of file
diff --git a/src/nodes/scene-controller/init.ts b/src/nodes/scene-controller/init.ts
index a845323..dcc3521 100644
--- a/src/nodes/scene-controller/init.ts
+++ b/src/nodes/scene-controller/init.ts
@@ -4,6 +4,8 @@ declare const RED: EditorRED;
 
 interface Defaults extends EditorNodeProperties {
   values: "percent" | "absolute";
+  playMode: "switch" | "add";
+  blackoutOnStop: boolean;
 }
 
 const def: EditorNodeDef<Defaults> = {
@@ -17,6 +19,13 @@ const def: EditorNodeDef<Defaults> = {
       value: "percent",
       required: true,
     },
+    playMode: {
+      value: "switch",
+      required: true,
+    },
+    blackoutOnStop: {
+      value: false,
+    },
   },
   inputs: 1,
   outputs: 1,
diff --git a/src/nodes/scene-controller/locales/de.json b/src/nodes/scene-controller/locales/de.json
index 238deef..1ae4ffe 100644
--- a/src/nodes/scene-controller/locales/de.json
+++ b/src/nodes/scene-controller/locales/de.json
@@ -2,6 +2,10 @@
   "label": {
     "values": "Werte",
     "values_percent": "Prozent (0–100)",
-    "values_absolute": "Absolut (0–255)"
+    "values_absolute": "Absolut (0–255)",
+    "playMode": "Wiedergabe",
+    "playMode_switch": "Umschalten (neue Szene ersetzt)",
+    "playMode_add": "Addieren (Szenen stapeln, HTP)",
+    "blackoutOnStop": "Beim Stoppen Nullwerte senden"
   }
 }
diff --git a/src/nodes/scene-controller/locales/en-US.json b/src/nodes/scene-controller/locales/en-US.json
index 312a78c..e1c1a9b 100644
--- a/src/nodes/scene-controller/locales/en-US.json
+++ b/src/nodes/scene-controller/locales/en-US.json
@@ -2,6 +2,10 @@
   "label": {
     "values": "values",
     "values_percent": "percent (0–100)",
-    "values_absolute": "absolute (0–255)"
+    "values_absolute": "absolute (0–255)",
+    "playMode": "Playback",
+    "playMode_switch": "Switch (new scene replaces)",
+    "playMode_add": "Add (stack scenes, HTP)",
+    "blackoutOnStop": "Send zero values on stop"
   }
 }
diff --git a/src/nodes/scene-controller/scene-controller.ts b/src/nodes/scene-controller/scene-controller.ts
index 39549e8..2f3021c 100644
--- a/src/nodes/scene-controller/scene-controller.ts
+++ b/src/nodes/scene-controller/scene-controller.ts
@@ -3,7 +3,10 @@ import { NodeMessage } from "@node-red/registry";
 import { DMXValues, maxValue, nulledUniverse, ValueScale } from "../../lib/dmx";
 import { SceneStore } from "../../lib/scene-store";
 
-type SceneControllerAction = "save" | "play" | "reset";
+type SceneControllerAction = "save" | "play" | "stop" | "reset";
+
+/** whether a new play replaces the running look ("switch") or stacks on top of it ("add") */
+type PlayMode = "switch" | "add";
 
 interface Universes {
   [key: number]: DMXValues;
@@ -16,6 +19,8 @@ interface Scene {
 
 export interface Config extends NodeDef {
   values?: ValueScale;
+  playMode?: PlayMode;
+  blackoutOnStop?: boolean;
 }
 
 type MessageInPayload =
@@ -36,6 +41,7 @@ interface MessageIn extends NodeMessage {
 interface MessageOut extends NodeMessage {
   scene: number;
   reset?: boolean;
+  stopped?: boolean;
   universe?: number | undefined;
   payload: DMXValues | Universes;
 }
@@ -51,7 +57,10 @@ class NodeHandler {
 
   protected scenes: Record<number, Scene>;
 
-  protected playingScene: number | null = null;
+  protected playMode: PlayMode;
+
+  /** scenes whose look is currently on the output; more than one only in "add" mode */
+  protected activeScenes: Set<number> = new Set();
 
   constructor(node: Node<Config>, config: Config, store: SceneStore<Scene>) {
     this.node = node;
@@ -59,6 +68,7 @@ class NodeHandler {
     this.scale = config.values ?? "percent";
     this.store = store;
     this.scenes = store.load();
+    this.playMode = config.playMode ?? "switch";
 
     this.node.on("input", (msg) => {
       const message: MessageIn = msg as MessageIn;
@@ -74,6 +84,11 @@ class NodeHandler {
             this.handlePlay(message);
           }
           break;
+        case "stop":
+          if (this.validateStop(message)) {
+            this.handleStop(message);
+          }
+          break;
         case "reset":
           if (this.validateReset(message)) {
             this.handleReset(message);
@@ -303,6 +318,14 @@ class NodeHandler {
     return true;
   }
 
+  protected validateStop(message: MessageIn) {
+    if (!this.validateScene(message)) {
+      return false;
+    }
+
+    return true;
+  }
+
   protected validateReset(_: MessageIn) {
     // nothing required yet.
     return true;
@@ -316,29 +339,69 @@ class NodeHandler {
     this.store.save(this.scenes);
   }
 
-  protected handlePlay(message: MessageIn): void {
-    const data: Scene | undefined = this.scenes[message.scene];
-    if (!data) {
-      this.node.warn(`Cannot play scene no. ${message.scene} since it has not been recorded yet.`);
+  /** combine every active scene into one look, per channel by HTP (highest value wins) */
+  protected mergeActiveScenes(): Universes {
+    const combined: Universes = {};
 
-      return;
+    for (const id of this.activeScenes) {
+      const scene = this.scenes[id];
+      if (!scene) {
+        continue;
+      }
+
+      for (const universeKey of Object.keys(scene.data)) {
+        const universe = parseInt(universeKey, 10);
+        const channels = scene.data[universe];
+        const target = combined[universe] ?? (combined[universe] = {});
+
+        for (const channelKey of Object.keys(channels)) {
+          const channel = parseInt(channelKey, 10);
+          target[channel] = Math.max(target[channel] ?? 0, channels[channel]);
+        }
+      }
     }
 
-    this.playingScene = message.scene;
+    return combined;
+  }
+
+  /** shape universes for output: a single universe is flattened + tagged with its number */
+  protected shapeOutput(universes: Universes): { payload: DMXValues | Universes; universe: number | undefined } {
+    const keys = Object.keys(universes);
+
+    if (keys.length === 1) {
+      const universe = parseInt(keys[0], 10);
+
+      return { payload: universes[universe], universe };
+    }
+
+    return { payload: universes, universe: undefined };
+  }
+
+  /** build an all-zero look for exactly the universes the given scene covers */
+  protected buildBlackout(data: Universes): { payload: DMXValues | Universes; universe: number | undefined } {
+    const universes = Object.keys(data);
 
-    let payload: Universes | DMXValues;
-    let universe: number | undefined = undefined;
-    const universes = Object.keys(data.data);
     if (universes.length === 1) {
-      universe = parseInt(universes[0], 10);
-      payload = data.data[universe];
-    } else {
-      payload = data.data;
+      return { payload: nulledUniverse(), universe: parseInt(universes[0], 10) };
     }
 
+    const payload: Universes = {};
+    universes.forEach((universe) => {
+      payload[parseInt(universe, 10)] = nulledUniverse();
+    });
+
+    return { payload, universe: undefined };
+  }
+
+  /** emit the combined look of all currently active scenes and reflect it in the node status */
+  protected emitActiveLook(scene: number, topic?: string): void {
+    const { payload, universe } = this.shapeOutput(this.mergeActiveScenes());
+    const count = this.activeScenes.size;
+    const label = count === 1 ? (topic ?? `Scene ${scene}`) : `${count} scenes`;
+
     const out: MessageOut = {
-      topic: message.topic ?? `Scene ${message.scene}`,
-      scene: message.scene,
+      topic: topic ?? label,
+      scene: scene,
       payload: payload,
       universe: universe,
     };
@@ -347,36 +410,85 @@ class NodeHandler {
     this.node.status({
       fill: "green",
       shape: "dot",
-      text: message.topic ?? `Scene ${message.scene}`,
+      text: label,
+    });
+  }
+
+  protected standby(): void {
+    this.node.status({
+      fill: "green",
+      shape: "ring",
+      text: "Standby",
     });
   }
 
+  protected handlePlay(message: MessageIn): void {
+    const data: Scene | undefined = this.scenes[message.scene];
+    if (!data) {
+      this.node.warn(`Cannot play scene no. ${message.scene} since it has not been recorded yet.`);
+
+      return;
+    }
+
+    // "switch" replaces the running look; "add" stacks the new scene on top of it (HTP)
+    if (this.playMode === "switch") {
+      this.activeScenes = new Set([message.scene]);
+    } else {
+      this.activeScenes.add(message.scene);
+    }
+
+    this.emitActiveLook(message.scene, message.topic);
+  }
+
+  protected handleStop(message: MessageIn): void {
+    // stopping a scene that is not on the output has no effect
+    if (!this.activeScenes.has(message.scene)) {
+      return;
+    }
+
+    const stopped: Scene | undefined = this.scenes[message.scene];
+    this.activeScenes.delete(message.scene);
+
+    if (this.activeScenes.size === 0) {
+      this.standby();
+
+      // the scene keeps its stored data; the output only goes dark when configured
+      if (this.config.blackoutOnStop && stopped) {
+        const { payload, universe } = this.buildBlackout(stopped.data);
+
+        const out: MessageOut = {
+          topic: `Scene ${message.scene}`,
+          scene: message.scene,
+          payload: payload,
+          universe: universe,
+          stopped: true,
+        };
+        this.node.send(out);
+      }
+
+      return;
+    }
+
+    // other scenes remain active: re-emit the combined look without the stopped one
+    this.emitActiveLook(message.scene, message.topic);
+  }
+
   protected handleReset(message: MessageIn): void {
     const resetScene = (scene: number) => {
       const data: Scene | undefined = this.scenes[scene];
+      const wasActive = this.activeScenes.delete(scene);
 
-      if (this.playingScene === scene) {
-        this.playingScene = null;
+      delete this.scenes[scene];
+
+      if (!wasActive) {
+        return;
+      }
 
-        this.node.status({
-          fill: "green",
-          shape: "ring",
-          text: "Standby",
-        });
+      if (this.activeScenes.size === 0) {
+        this.standby();
 
         if (data) {
-          const universes = Object.keys(data.data);
-          let universe: number | undefined = undefined;
-          let payload: DMXValues | Universes;
-          if (universes.length === 1) {
-            universe = parseInt(universes[0], 10);
-            payload = nulledUniverse();
-          } else {
-            payload = {};
-            universes.forEach((universe) => {
-              payload[parseInt(universe, 10)] = nulledUniverse();
-            });
-          }
+          const { payload, universe } = this.buildBlackout(data.data);
 
           const out: MessageOut = {
             topic: `Scene ${scene}`,
@@ -387,9 +499,10 @@ class NodeHandler {
           };
           this.node.send(out);
         }
+      } else {
+        // in "add" mode other scenes stay on the output: re-emit the remaining look
+        this.emitActiveLook(scene);
       }
-
-      delete this.scenes[scene];
     };
 
     if (message.scene) {