🙋 Frequently Asked Questions

🧩 Dynamic Actions Overview

IsoKey features a highly modular plugin infrastructure that allows developers to implement, test, and register custom hotkey actions dynamically without altering the host code. By placing compiled assemblies (DLLs) in the Actions/ subdirectory of the runtime, IsoKey automatically discovers, categorizes, lists, configures, and dispatches keystroke handlers on execution.

The SDK exposes two developer-facing interfaces depending on execution complexity:

• IDynamicActionPlugin: Used for advanced, stateful actions. It encapsulates metadata details (custom themes, names, descriptions) and yields a custom WPF UserControl to support real-time configuration.
• IActionPlugin: Used for static built-in system mappings (e.g. launching standard applications).

🚀 Quickstart Guide

Get a custom dynamic action plugin running inside IsoKey in a few easy steps:

1. Create a Class Library Project: Create a new Class Library project targeting .NET 9.0 in Visual Studio or Rider. Ensure you target the Windows SDK variant (e.g., net9.0-windows10.0.17763.0).
2. Configure the Project File (.csproj): Enable WPF and Windows Forms support in your project settings so you can design UI elements, and reference KeyboardRemapper.csproj (or the compiled KeyboardRemapper.dll).
3. Implement the Interfaces: Create a class implementing IDynamicActionPlugin. Optionally implement IGlobalSettingsProvider for persistent global setup configurations.
4. Build and Deploy: Build the project in Release mode, and copy the generated DLL assembly directly to the Actions/ folder inside the IsoKey execution folder.
5. Verify and Test: Launch IsoKey. Check the Action Studio interface to confirm your plugin is loaded and available for keyboard remapping assignments.

⚙️ IDynamicActionPlugin Specification

This interface defines the entry point for custom modular plugins. Implementations are loaded and instantiated dynamically via reflection.

using System;
using System.Windows.Controls;
using KeyboardRemapper.Core;

namespace KeyboardRemapper.Models
{
    public interface IDynamicActionPlugin
    {
        string PluginId { get; }
        string DisplayName { get; }
        string Description { get; }
        string Category { get; }
        string Color { get; }
        string Icon { get; }

        UserControl CreateConfigControl(KeyboardAction action, Action onDirty);
        bool SaveSettings(KeyboardAction action);
        void Execute(KeyboardAction action, InputManager manager, int vk, int chainDepth);
        bool IsDefaultOrSuggestedName(string name) => string.IsNullOrEmpty(name) || name.StartsWith(DisplayName, StringComparison.OrdinalIgnoreCase);
    }
}

Property & Method Descriptions

🌐 IGlobalSettingsProvider Specification

Implement this interface alongside IDynamicActionPlugin to inject custom global configuration tabs directly into the main Settings Window sidebar. This is ideal for plugins requiring shared configuration, credentials, or API tokens rather than per-action configurations.

using System;
using System.Windows.Controls;
using KeyboardRemapper.Core;

namespace KeyboardRemapper.Models
{
    public interface IGlobalSettingsProvider
    {
        string SettingsTabHeader { get; }
        string SettingsTabTag { get; }

        UserControl CreateSettingsControl(InputManager manager, Action onDirty);
        void SaveSettings(InputManager manager);
    }
}

⚡ IActionPlugin Specification

For simple execution scripts mapped to built-in system events, the static interface handles dispatching through standard mapped action enum tags.

namespace KeyboardRemapper.Core
{
    public interface IActionPlugin
    {
        ActionType ActionType { get; }
        void Execute(KeyboardAction action, InputManager manager, int vk, int chainDepth);
    }
}

📖 API Reference & Core Types

To interface with the host environment, plugins use core models and services from the KeyboardRemapper namespace. The main classes and types are defined below.

1. KeyboardAction Class

Represents a mapping configuration instance. Use this object to load, modify, and store configuration details.

2. InputManager Class

The core execution controller engine. Provides methods to update host status, trigger secondary actions, and retrieve environmental values.

3. System Logging Integration

Plugins can write real-time log entries to the host application's debug console ring buffer. This output appears inside the host's System Log Window.

using KeyboardRemapper.UI.Windows;

// Log general system information
SystemLogWindow.AppLog("My custom plugin initialized.", LogType.System);

// Log action events
SystemLogWindow.AppLog("Failed to query local database.", LogType.Action);

The second parameter is the LogType enum from the KeyboardRemapper.UI.Windows namespace, supporting: System, Key, and Action.

🎨 Configuration UI Integration

When implementing CreateConfigControl, the plugin must return a WPF UserControl. The control is dynamically hosted in the Action Studio editing window. Follow these guidelines to build your control:

1. State Restoration: On loading, the control should deserialize configuration states stored in action.Arguments (typically using JSON).
2. Interactive Modifiers: Invoke the provided onDirty action callback whenever the user updates fields, which toggles the Action Studio's unsaved changes indicator.
3. Saving Payload: Write all configuration fields to action.Arguments inside SaveSettings, or update them in real-time as state modifications occur.
4. Target Summary & Auto-naming: Update action.Target to describe the configured behavior dynamically. Check if action.Name starts with "New " or matches other default template prefixes, and if so, automatically override it with a descriptive name representing the specific action settings.
5. Dynamic Custom Icons: Set action.CustomIconPath = "Glyph:<Segoe_MDL2_Glyph>" dynamically when selection changes or in SaveSettings. Setting this path allows your action to dynamically update its visual style on the Dashboard tiles and layout keys based on the active operation mode.

🖌️ WPF Styling & Shared Native Resources

Custom user controls do not need to redefine dark-mode themes, buttons, textboxes, or sliders. Because the WPF control is added directly to the visual tree of the IsoKey host, it automatically inherits all host application resources.

1. Reusable Host Style Keys

Apply these styles to standard WPF components using the Style="{StaticResource StyleKey}" property format to match native visual aesthetics:

2. Layout Guidelines

• The available content space is dynamic, but typically fits inside a standard width of 400px. Use vertical stacking layout (like a StackPanel or Grid with auto-sizing rows).
• Design your user control elements to look compact. Use clean font sizes: 11 or 12 for checkboxes and descriptions, and 10 bold with dark gray foreground headers (e.g. #555) for settings groups.

3. Reference XAML Code Example

<UserControl x:Class="KeyboardRemapper.Plugins.MyCustomConfigControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <StackPanel Margin="0,10,0,0">
        <!-- Label Header -->
        <TextBlock Text="CONFIGURATION SETTINGS" FontSize="10" Foreground="#555" FontWeight="Bold" Margin="0,0,0,8"/>
        
        <!-- Shared Native TextBox -->
        <TextBox Style="{StaticResource ModernTextBox}" Height="38" FontSize="12" Padding="10,0,10,0" 
                 VerticalContentAlignment="Center" TextChanged="TextBox_TextChanged"/>
    </StackPanel>
</UserControl>

💾 Data Persistence

For stateful action plugins, settings specific to an individual key mapping should be stored inside the KeyboardAction.Arguments JSON string. However, plugins often require shared global state, credentials, or API keys (e.g. OpenAI or Gemini keys) that apply to all instances of the action. To avoid writing to ad-hoc flat JSON files which can cause pathing or file lock conflicts, the host provides a unified database persistence interface: PluginPersistenceService.

All data managed through this service is serialized to JSON and persisted within the shared database file config_a.db under a dedicated "plugin_data" collection.

Persistence Strategy Comparison

Using PluginPersistenceService

using KeyboardRemapper.Core.Services;

// Define a model for your settings
public class MyPluginSettings
{
    public string ApiKey { get; set; } = "";
    public bool EnableFeature { get; set; } = true;
}

// 1. Save settings using a unique plugin settings key
var config = new MyPluginSettings { ApiKey = "XYZ-123" };
PluginPersistenceService.Save("MyPlugin_GlobalSettings", config);

// 2. Load settings back (returns default/null if not yet saved)
var loaded = PluginPersistenceService.Load<MyPluginSettings>("MyPlugin_GlobalSettings");
if (loaded != null)
{
    string key = loaded.ApiKey;
}

💡 Development Guidelines & Best Practices

To ensure high performance, stability, and seamless host application execution, dynamic plugins should adhere to the following architectural design patterns:

1. Threading & WPF Dispatcher Integration

Hotkeys intercepted during runtime invoke the Execute() handler on a background listener hook thread. Direct modifications of UI elements or access to APIs requiring Single Thread Apartment (STA) state (such as the Windows Clipboard) will fail or throw cross-thread exceptions if performed directly on the hook thread.

Use the global WPF Dispatcher to marshal UI operations safely onto the main application thread:

// Execute UI or Clipboard operations safely from background hook thread
System.Windows.Application.Current.Dispatcher.Invoke(() =>
{
    // Write clipboard text safely
    System.Windows.Clipboard.SetText("Transformed Output Text");
});

2. Exception Handling & Host Protection

Unhandled exceptions originating inside a plugin's Execute(), SaveSettings(), or configuration controls can crash the main IsoKey host process. Always wrap execution logic inside structured try-catch blocks to capture faults gracefully.

try
{
    // Run your main execution logic here
}
catch (Exception ex)
{
    // Notify the user via the host status bar
    manager.UpdateStatus($"Plugin execution failed: {ex.Message}");
    System.Diagnostics.Debug.WriteLine($"Plugin Error: {ex}");
}

🐞 Debugging & Troubleshooting

To inspect values and step through your plugin code dynamically, you can configure your IDE to attach to the host application process.

1. Attaching Debugger in Visual Studio / Rider

1. Open project properties and navigate to the Debug / Run Configuration settings.
2. Set the Start Action to Start External Program.
3. Browse and select the compiled IsoKey.exe binary executable from your local repository build folder.
4. Set the Working Directory to the directory containing IsoKey.exe.
5. Press F5 to build your library, copy the output DLL assembly to the Actions/ directory, launch the host application, and begin debugging.

2. Dynamic DLL File Locking

To streamline development, you can add a pre-build command to automatically terminate any active IsoKey process instances before building your project:

taskkill /f /im IsoKey.exe 2>nul || exit 0

3. Method Invocation Lifecycle

• On Host Launch: The host scans the Actions/ subdirectory, instantiates one singleton instance of your plugin class, and calls the global configuration loader (if IGlobalSettingsProvider is implemented).
• On Action Configuration: When a user edits a mapping configuration for your action in Action Studio, the host invokes CreateConfigControl() to load the configuration panel view, and triggers SaveSettings() when the user clicks save.
• On Key Press (Triggered): Whenever the mapped keystroke is pressed, the host dispatches the hook event to your Execute() handler.

📦 Compiling & Loading

Plugin libraries must target the same target framework as the host application, which is net9.0-windows10.0.17763.0, and must enable both WPF and Windows Forms support.

Sample Project Configuration (.csproj)

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net9.0-windows10.0.17763.0</TargetFramework>
    <UseWPF>true</UseWPF>
    <UseWindowsForms>true</UseWindowsForms>
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\KeyboardRemapper.csproj" />
  </ItemGroup>
</Project>

Distribution Pipeline

Compiled plugin DLLs must be placed directly inside the Actions/ directory relative to the IsoKey.exe executable directory. The application's automatic assembly loading engine handles mapping resolving without requiring manual registry operations.

📋 Example Implementations

1. Macro Recorder Plugin

Below is a skeletal implementation of the MacroRecorderPlugin demonstrating dynamic configuration injection and input playback under the Workspace Productivity category.

using System;
using System.Windows.Controls;
using KeyboardRemapper.Core;
using KeyboardRemapper.Models;

namespace KeyboardRemapper.Plugins
{
    public class MacroRecorderPlugin : IDynamicActionPlugin
    {
        public string PluginId => "MacroRecorder";
        public string DisplayName => "Macro Recorder";
        public string Description => "Record and playback mouse and key events.";
        public string Category => "Workspace Productivity";
        public string Color => "#8E24AA";
        public string Icon => "🎙️";

        public UserControl CreateConfigControl(KeyboardAction action, Action onDirty)
        {
            return new MacroRecorderConfigControl(action, onDirty);
        }

        public bool SaveSettings(KeyboardAction action)
        {
            return true;
        }

        public void Execute(KeyboardAction action, InputManager manager, int vk, int chainDepth)
        {
            // Execute playback using Win32 SendInput API...
        }
    }
}

2. Text Transformer Plugin

Below is a skeletal implementation of the standalone TextTransformerPlugin demonstrating global text manipulation via simulated clipboard copy-paste events under the Workspace Productivity category.

using System;
using System.Windows;
using System.Windows.Controls;
using KeyboardRemapper.Core;
using KeyboardRemapper.Models;

namespace KeyboardRemapper.Plugins
{
    public class TextTransformerPlugin : IDynamicActionPlugin
    {
        public string PluginId => "TextTransformer";
        public string DisplayName => "Text Transformer";
        public string Description => "Transform selected text dynamically with a hotkey.";
        public string Category => "Workspace Productivity";
        public string Color => "#00BCD4";
        public string Icon => "🔤";

        public UserControl CreateConfigControl(KeyboardAction action, Action onDirty)
        {
            return new TextTransformerConfigControl(action, onDirty);
        }

        public bool SaveSettings(KeyboardAction action)
        {
            return true;
        }

        public void Execute(KeyboardAction action, InputManager manager, int vk, int chainDepth)
        {
            // Must run in STA thread context to access clipboard
            Application.Current.Dispatcher.Invoke(() =>
            {
                // 1. Simulate Ctrl+C to copy current text selection
                // 2. Transform the text on the Clipboard
                // 3. Simulate Ctrl+V to paste the transformed text back
            });
        }
    }
}

3. Connection Manager Plugin

Below is a skeletal implementation of the ConnectionManagerPlugin demonstrating complex system network status changes, custom dynamic icon generation, and Win32 interop operations under the System Tools category.

using System;
using System.Text.Json;
using System.Threading.Tasks;
using System.Windows.Controls;
using KeyboardRemapper.Core;
using KeyboardRemapper.Models;

namespace KeyboardRemapper.Plugins
{
    public enum ConnectionMode
    {
        WiFiToggle,
        WiFiConnect,
        WiFiDisconnect,
        BluetoothToggle,
        BluetoothDeviceConnect,
        BluetoothDeviceDisconnect,
        AirplaneModeToggle,
        HotspotToggle,
        VpnConnect,
        VpnDisconnect,
        ProxyToggle,
        FlushDns,
        RenewIp
    }

    public class ConnectionConfigData
    {
        public ConnectionMode Mode { get; set; } = ConnectionMode.WiFiToggle;
        public string WiFiSsid { get; set; } = "";
        public string WiFiPassword { get; set; } = "";
        public string BluetoothDeviceAddress { get; set; } = "";
        public string BluetoothDeviceName { get; set; } = "";
        public string VpnName { get; set; } = "";
        public string ProxyServer { get; set; } = "";
    }

    public class ConnectionManagerPlugin : IDynamicActionPlugin
    {
        public string PluginId => "ConnectionManager";
        public string DisplayName => "Connection Manager";
        public string Description => "Control network connections: Wi-Fi, Bluetooth, Airplane Mode, VPN, and System Proxy.";
        public string Category => "System Tools";
        public string Color => "#FF5722";
        public string Icon => "\uE701"; // Default Wi-Fi Glyph

        public UserControl CreateConfigControl(KeyboardAction action, Action onDirty)
        {
            return new ConnectionManagerConfigControl(action, onDirty);
        }

        public bool SaveSettings(KeyboardAction action)
        {
            try
            {
                if (!string.IsNullOrEmpty(action.Arguments))
                {
                    var data = JsonSerializer.Deserialize<ConnectionConfigData>(action.Arguments);
                    if (data != null)
                    {
                        // Dynamically update custom Segoe MDL2 icon glyph based on selected mode
                        string iconGlyph = data.Mode switch
                        {
                            ConnectionMode.WiFiToggle or ConnectionMode.WiFiConnect or ConnectionMode.WiFiDisconnect => "\uE701",
                            ConnectionMode.BluetoothToggle or ConnectionMode.BluetoothDeviceConnect or ConnectionMode.BluetoothDeviceDisconnect => "\uE702",
                            ConnectionMode.AirplaneModeToggle => "\uE709",
                            ConnectionMode.HotspotToggle => "\uE704",
                            ConnectionMode.VpnConnect or ConnectionMode.VpnDisconnect => "\uE727",
                            ConnectionMode.ProxyToggle => "\uF13D",
                            ConnectionMode.FlushDns or ConnectionMode.RenewIp => "\uE756",
                            _ => "\uE701"
                        };
                        action.CustomIconPath = "Glyph:" + iconGlyph;
                    }
                }
            }
            catch { }
            return true;
        }

        public void Execute(KeyboardAction action, InputManager manager, int vk, int chainDepth)
        {
            // Parse arguments and asynchronously trigger target network/device operations
            Task.Run(async () =>
            {
                try
                {
                    var config = JsonSerializer.Deserialize<ConnectionConfigData>(action.Arguments) ?? new ConnectionConfigData();
                    switch (config.Mode)
                    {
                        case ConnectionMode.WiFiToggle:
                            // Toggle Wi-Fi radio state...
                            break;
                        case ConnectionMode.BluetoothDeviceConnect:
                            // Connect paired Bluetooth device via Windows.Devices.Bluetooth API...
                            break;
                        // Additional network/system control handlers...
                    }
                }
                catch (Exception ex)
                {
                    manager.UpdateStatus($"Connection Manager failed: {ex.Message}");
                }
            });
        }
    }
}

🖼️ Overview & Setup

Custom Script elements allow you to inject vanilla JavaScript directly into your Overlay Panel. You can write custom UI layouts, construct canvas graphics, and synchronize them in real time with hardware monitoring statistics (telemetry) via clean, sandboxed lifecycle hooks.

⚙️ Custom Widget Settings on the Element Properties Tab

IsoKey supports a powerful dynamic settings system. Developers can expose custom, configurable parameters for their custom scripts directly in the Overlay Studio's Element Properties tab. By adding special comment-based metadata directives at the top of a JavaScript widget file, the host designer automatically reads the file and builds visual editing controls (like checkboxes, text boxes, and interactive color pickers) inside the element properties sidebar for the user to configure.

Declare each custom setting at the top of your JavaScript file using the following metadata comment format:

// @setting: [key]|[type]|[label]|[defaultValue]

Parameter Breakdown:

• key: The variable key used to access this setting in the style object passed to onCreate(container, style) (e.g. showControls).
• type: The editor control type to generate. Supported types:
  • boolean or bool: Generates a CheckBox.
  • color: Generates a color preview block and button that launches the top-level, DPI-aware **IsoColorPickerWindow** (supporting real-time canvas preview updates and automatic cancel-to-revert actions if dismissed).
  • choice[opt1,opt2,...] or select[opt1,opt2,...]: Generates a dropdown ComboBox featuring the listed choices, automatically capitalized for user display (e.g. choice[vinyl,compact,retro]).
  • text or string or number: Generates a standard TextBox.
• label: The user-friendly label displayed in the Element Properties sidebar (e.g. Show Controls).
• defaultValue (optional): The default value assigned if the user hasn't explicitly set one.

Example Script Declaration:

// @setting: accentColor|color|Accent Color|#00ffcc
// @setting: showLocation|boolean|Show Location Name|true
// @setting: customText|text|Custom Title|WEATHER SPOT

class WeatherWidget {
    onCreate(container, style) {
        // Retrieve the user settings from the style parameter:
        const accent = style.accentColor || '#00ffcc';
        const showLoc = style.showLocation !== false && style.showLocation !== 'false';
        const title = style.customText || 'WEATHER SPOT';
        
        // Build your widget UI using these dynamic settings...
    }
}

🔄 Lifecycle Hooks

Custom scripts must implement a standard ES6 class structure. The SDK automatically calls these lifecycle methods during runtime:

1. onCreate(container, style)

Called when the element is instantiated in the Web Deck. Use this to construct your DOM nodes, set up canvas contexts, and bind initial layouts.

• container: The shadow-root host DOM element. Draw all visual nodes inside this wrapper.
• style: A raw CSS config string passed from the overlay panel settings.

2. onStatsUpdate(container, stats)

Called automatically when a new hardware stats or telemetry packet is received via the WebSocket server connection (typically every 1 second).

• container: The host wrapper DOM element.
• stats: A parsed JSON packet containing active hardware statistics.

3. onDestroy(container)

Called when swapping active overlays or closing the dashboard layout. Use this to cancel animation loops, clear interval timers, and prevent memory leaks.

📊 Telemetry Payload

The stats parameter inside onStatsUpdate contains the following real-time data attributes:

🔗 Bidirectional API Reference

Custom scripts can interactively trigger remap operations, launch applications, or toggle audio sliders by utilizing the native window.IsoKeyAPI helper namespace:

🖼️ Local HTTP Media & Asset APIs

Custom HTML elements can fetch local dynamic media files and asset icons from the loopback web server using the following HTTP API endpoints:

📐 Sizing & Responsive Widget Scaling

To ensure custom script elements look consistent across multiple remote device resolutions (e.g. mobile screens, tablets) and the XAML overlay editor canvas, the SDK implements a unified size-independent scaling engine.

1. Always Use Relative Units (em)

Avoid absolute sizing units like px for layouts, border-radii, padding, and text. Instead, use relative em units. The SDK dynamically controls the container's base font-size depending on the element's actual dimensions:

• The container's base font size automatically adjusts relative to the smallest dimension using min(width, height).
• In the HTML remote web deck, the base font size is synced via ResizeObserver at 5% of the smallest dimension (capped at a 6px minimum).
• In the XAML studio preview control, a 2.5x layout scale compensation is automatically applied to guarantee that zoomXaml: 1.0 matches the remote HTML scale perfectly.

2. High-DPI Canvas Sizing

If utilizing an HTML5 <canvas> element for graphics (e.g. analog gauges, battery rings), clear pixelation on high-DPI retina mobile screens by adjusting the canvas rendering resolution using window.devicePixelRatio:

// Inside draw/render tick:
const rect = canvas.getBoundingClientRect();
const dpr = window.devicePixelRatio || 1;
const w = rect.width;
const h = rect.height;

if (canvas.width !== Math.round(w * dpr) || canvas.height !== Math.round(h * dpr)) {
    canvas.width = Math.round(w * dpr);
    canvas.height = Math.round(h * dpr);
}

ctx.save();
ctx.scale(dpr, dpr);
ctx.clearRect(0, 0, w, h);

// Draw your elements using base client sizes (w, h) and relative radius scale...
ctx.restore();

📝 Digital Clock Example

Below is a complete class template for creating a sweeping Digital Clock showing real-time CPU stats:

class DigitalClock {
    onCreate(container, style) {
        // Initialize visual DOM nodes
        const wrapper = document.createElement('div');
        wrapper.style.cssText = 'width:100%; height:100%; display:flex; flex-direction:column; align-items:center; justify-content:center; color:#00ffcc;';
        
        const timeEl = document.createElement('div');
        timeEl.style.cssText = 'font-size:2.4em; font-weight:bold; text-shadow:0 0 0.3em rgba(0,255,204,0.5);';
        wrapper.appendChild(timeEl);
        
        const subEl = document.createElement('div');
        subEl.style.cssText = 'font-size:1.1em; margin-top:0.4em; opacity:0.7;';
        subEl.innerText = 'CPU Load: --%';
        wrapper.appendChild(subEl);
        
        container.appendChild(wrapper);
        
        this.timeEl = timeEl;
        this.subEl = subEl;
        
        // Sweep clock update ticks
        const updateTime = () => {
            const d = new Date();
            this.timeEl.innerText = d.toTimeString().split(' ')[0];
        };
        updateTime();
        this.timer = setInterval(updateTime, 1000);
    }
    
    onStatsUpdate(container, stats) {
        // Update telemetry data elements
        if (this.subEl && stats.Cpu !== undefined) {
            this.subEl.innerText = `CPU Load: ${Math.round(stats.Cpu)}%`;
        }
    }
    
    onDestroy(container) {
        // Prevent memory leaks
        clearInterval(this.timer);
    }
}

// Register the class with the IsoKey SDK
window.CustomElementRegistry.register('DigitalClock', DigitalClock);

🎙️ Discord Voice IPC Bridge

The Web Deck includes robust Discord integration which connects directly to the local Discord client via high-performance Named Pipes (discord-ipc-0), avoiding typical origin-policy and CORS constraints of web browser pages.

Outgoing API Methods

Real-Time Discord Telemetry Properties

Stats update broadcasts (onStatsUpdate) populate the following Discord voice telemetry variables:

• DiscordConnected (boolean) - Connection health status to the local Discord client.
• DiscordMuted (boolean) - Active microphone mute status.
• DiscordDeafened (boolean) - Active client deafen (speaker mute) status.
• DiscordActiveSpeakers (string[]) - Array of nicknames/usernames currently speaking.
• DiscordChannelName (string) - Name of the currently joined voice channel.
• DiscordGuildName (string) - Name of the server guild for the voice channel.
• DiscordVoiceUsers (array) - Array of voice channel user objects.

📡 OBS Studio Control

Control and monitor OBS Studio in real time from custom overlay elements.

Outgoing API Methods

Real-Time OBS Telemetry Properties

Stats update broadcasts (onStatsUpdate) populate these real-time OBS telemetry variables:

• ObsConnected (boolean) - Connection status to OBS Studio.
• ObsCurrentScene (string) - The active program scene.
• ObsIsStreaming (boolean) - Stream active flag.
• ObsIsRecording (boolean) - Record active flag.
• ObsMutedInputs (object) - Key-value pair of input name to mute state (boolean).
• ObsInputVolumes (object) - Key-value pair of input name to volume multiplier (number).