Stream fromAny Desktop

Install WAVE Desktop via package managers or direct download:

brew install --cask wave-desktop
# Or download directly: https://downloads.wave.online/desktop/macos/latest

winget install WAVE.Desktop
# Or download installer: https://downloads.wave.online/desktop/windows/latest

# Ubuntu/Debian
curl -fsSL https://downloads.wave.online/linux/apt/gpg | sudo apt-key add -
sudo add-apt-repository "deb https://downloads.wave.online/linux/apt stable main"
sudo apt update && sudo apt install wave-desktop

# Fedora/RHEL
sudo dnf config-manager --add-repo https://downloads.wave.online/linux/rpm/wave.repo
sudo dnf install wave-desktop

Securely connect your desktop app to your WAVE cloud account:

// 1. Launch WAVE Desktop
// 2. Click "Pair with Cloud Account"
// 3. Visit: https://wave.online/dashboard/nodes/add
// 4. Enter the 6-digit code displayed in the app (e.g., "AB-CD-EF")

// API endpoint for programmatic pairing:
POST https://api.wave.online/v1/nodes/pair
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json

Body:
{
  "pairing_code": "AB-CD-EF",
  "node_name": "Office Desktop",
  "location": "San Francisco HQ"
}

Response:
{
  "node_id": "node_abc123",
  "status": "paired",
  "expires_at": "2024-01-15T10:30:00Z",
  "secure_token": "eyJhbGciOiJIUzI1NiIs..."
}

Configure screen capture programmatically via the Desktop API:

// Desktop API runs on localhost:8080 when app is running
const desktopApi = 'http://localhost:8080/api/v1';

// List available displays
const displays = await fetch(`${desktopApi}/sources/displays`).then(r => r.json());
// Returns: [{ id: "display_0", name: "Built-in Display", width: 1920, height: 1080, primary: true }]

// Configure screen capture
await fetch(`${desktopApi}/sources/configure`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    source_type: "screen_capture",
    display_id: "display_0",
    capture_cursor: true,
    capture_audio: true,
    frame_rate: 60,
    region: { x: 0, y: 0, width: 1920, height: 1080 } // Optional: capture region
  })
});

// Start streaming the configured source
await fetch(`${desktopApi}/stream/start`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    protocol: "omt",
    quality: "high",
    bitrate: 8000000 // 8 Mbps
  })
});

Discover and stream from NDI sources on your network:

// Desktop API: Discover NDI sources
const ndiSources = await fetch('http://localhost:8080/api/v1/sources/ndi/discover', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    timeout: 5000, // Discovery timeout in ms
    groups: ["public"], // NDI groups to search
    extra_ips: ["192.168.1.100"] // Additional IPs to check
  })
}).then(r => r.json());

/* Response:
{
  "sources": [
    {
      "name": "CAMERA_1 (PTZ Camera)",
      "ip": "192.168.1.50",
      "url": "ndi://192.168.1.50/CAMERA_1",
      "groups": ["public"],
      "video": { "width": 1920, "height": 1080, "frame_rate": 59.94 },
      "audio": { "channels": 2, "sample_rate": 48000 }
    }
  ]
}
*/

// Connect to NDI source
await fetch('http://localhost:8080/api/v1/sources/configure', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    source_type: "ndi",
    ndi_source: "CAMERA_1 (PTZ Camera)",
    bandwidth: "highest", // "lowest" | "highest" | "audio_only"
    enable_tally: true // Send tally to NDI source
  })
});

Manage desktop nodes remotely from your cloud dashboard:

// Cloud API: List all desktop nodes
const nodes = await fetch('https://api.wave.online/v1/nodes', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}).then(r => r.json());

/* Response:
{
  "nodes": [
    {
      "node_id": "node_abc123",
      "name": "Office Desktop",
      "status": "online",
      "last_seen": "2024-01-15T10:30:45Z",
      "system": {
        "os": "macOS 14.1",
        "cpu_usage": 45.2,
        "memory_usage": 62.8,
        "gpu_usage": 38.5,
        "network_upload": 8500000 // bytes/sec
      },
      "current_stream": {
        "protocol": "omt",
        "bitrate": 8000000,
        "viewers": 1247,
        "uptime": 3600
      }
    }
  ]
}
*/

// Start stream on a node remotely
await fetch('https://api.wave.online/v1/nodes/node_abc123/stream/start', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    source_id: "camera_0",
    protocol: "srt",
    quality_preset: "production",
    destination: "stream_key_xyz"
  })
});

// Update node settings remotely
await fetch('https://api.wave.online/v1/nodes/node_abc123/settings', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    max_bitrate: 10000000,
    hardware_encoding: true,
    auto_reconnect: true,
    health_check_interval: 30
  })
});

Switch between multiple sources with transitions and overlays:

// Configure multiple sources
const sources = [
  { id: "camera_0", type: "camera", device: "USB Camera" },
  { id: "screen_0", type: "screen", display: "display_0" },
  { id: "ndi_0", type: "ndi", ndi_source: "CAMERA_1" }
];

// Add sources to scene
for (const source of sources) {
  await fetch('http://localhost:8080/api/v1/scene/sources', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      source_id: source.id,
      source_config: source,
      position: { x: 0, y: 0, width: 1920, height: 1080 },
      visible: source.id === "camera_0" // Only camera visible initially
    })
  });
}

// Switch to different source with transition
await fetch('http://localhost:8080/api/v1/scene/transition', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    target_source: "screen_0",
    transition_type: "fade", // "cut" | "fade" | "slide" | "wipe"
    duration_ms: 500
  })
});

// Add overlay (logo, lower third, etc.)
await fetch('http://localhost:8080/api/v1/scene/overlays', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    overlay_type: "image",
    source: "/path/to/logo.png",
    position: { x: 1720, y: 980, width: 180, height: 80 }, // Bottom-right
    opacity: 0.9,
    z_index: 100
  })
});

Record locally without internet connection, auto-upload when reconnected:

// Configure local recording
await fetch('http://localhost:8080/api/v1/recording/configure', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    enabled: true,
    output_directory: "/Users/username/Videos/WAVE",
    format: "mp4", // "mp4" | "mov" | "mkv"
    codec: "h264", // "h264" | "h265" | "vp9"
    quality: "high", // "low" | "medium" | "high" | "lossless"
    split_interval: 3600, // Split into 1-hour files
    auto_upload: true, // Upload to VAULT when online
    upload_priority: "wifi_only" // "always" | "wifi_only" | "manual"
  })
});

// Start recording
await fetch('http://localhost:8080/api/v1/recording/start', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    source_id: "camera_0",
    metadata: {
      title: "Conference Recording",
      tags: ["conference", "2024"],
      description: "Annual company conference keynote"
    }
  })
});

// Query recording status
const status = await fetch('http://localhost:8080/api/v1/recording/status')
  .then(r => r.json());

/* Response:
{
  "is_recording": true,
  "duration": 1847, // seconds
  "file_size": 1024000000, // bytes
  "current_file": "/Users/username/Videos/WAVE/recording_2024-01-15_10-30-00.mp4",
  "upload_queue": [
    { "file": "recording_2024-01-14_14-00-00.mp4", "progress": 67.5, "eta": 180 }
  ]
}
*/

Leverage GPU hardware encoding for efficient 4K streaming:

// Check available hardware encoders
const encoders = await fetch('http://localhost:8080/api/v1/system/encoders')
  .then(r => r.json());

/* Response:
{
  "available_encoders": [
    { "name": "h264_videotoolbox", "type": "hardware", "gpu": "Apple M2 Max", "max_resolution": "8K" },
    { "name": "h264_nvenc", "type": "hardware", "gpu": "NVIDIA RTX 4090", "max_resolution": "8K" },
    { "name": "hevc_nvenc", "type": "hardware", "gpu": "NVIDIA RTX 4090", "max_resolution": "8K" },
    { "name": "libx264", "type": "software", "cpu": "Intel i9-13900K", "max_resolution": "4K" }
  ],
  "recommended": "h264_nvenc"
}
*/

// Configure hardware encoding
await fetch('http://localhost:8080/api/v1/encoder/configure', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    encoder: "h264_nvenc", // Use NVIDIA hardware encoder
    preset: "p4", // NVIDIA presets: p1 (fastest) to p7 (slowest/best quality)
    profile: "high", // "baseline" | "main" | "high"
    level: "5.1", // H.264 level
    bitrate: 10000000, // 10 Mbps
    max_bitrate: 15000000, // VBR max
    buffer_size: 20000000, // Rate control buffer
    keyframe_interval: 120, // GOP size (frames)
    b_frames: 2, // Number of B-frames
    ref_frames: 3, // Reference frames

    // Advanced settings
    lookahead: true, // Enable lookahead (NVIDIA only)
    adaptive_quantization: "spatial", // "disabled" | "spatial" | "temporal"
    multipass: "fullres", // "disabled" | "quarter" | "fullres"

    // Quality optimizations
    low_latency: false, // Disable for better quality
    weighted_prediction: true,
    aq_strength: 8 // Adaptive quantization strength (1-15)
  })
});

// Monitor encoder performance
const stats = await fetch('http://localhost:8080/api/v1/encoder/stats')
  .then(r => r.json());

/* Response:
{
  "fps": 59.94,
  "cpu_usage": 15.2, // Low CPU usage with hardware encoding
  "gpu_usage": 68.5,
  "encoder_latency_ms": 8.3,
  "dropped_frames": 0,
  "quality_score": 98.7
}
*/