Skip to content
Smelter logo Smelter logo Smelter

Smelter

The primary element required to start using the Smelter TypeScript SDK is the Smelter class. This class is crucial for initializing and managing the Smelter server instance.

It is available in 2 variants for different runtimes:

  • Node.js 
    import Smelter from "@swmansion/smelter-node"
  • Browser (WASM) 
    import Smelter from "@swmansion/smelter-web-wasm"

new Smelter()

Creates a new Smelter instance. You have to call init() first before this object can be used.

Runtime: Node.js

new Smelter(manager?: SmelterManager)
Type definitions 

type ApiRequest = {
  method: 'GET' | 'POST';
  route: string;
  body?: object;
};


type MultipartRequest = {
  method: 'POST';
  route: string;
  body: any;
};


type SmelterManager = {
  setupInstance(): Promise<void>;
  sendRequest(request: ApiRequest): Promise<object>;
  sendMultipartRequest(request: MultipartRequest): Promise<object>;
  registerEventListener(cb: (event: unknown) => void): void;
}

manager

Configures how the client code will connect and manage a Smelter server. Smelter SDK provides 2 implementations that you can use or extend:


Runtime: Browser (WASM)

new Smelter(options: WebWasmSmelterOptions)
Type definitions 

type Framerate = {
  num: number;
  den: number;
};
type WebWasmSmelterOptions = {
  framerate?: Framerate | number;
  streamFallbackTimeoutMs: number;
};

See WebWasmSmelterOptions to learn more.

init()

Smelter.init(): Promise<void>

Initialize the Smelter instance. This might spawn a new instance or just establish a connection.

After init() you can start connecting inputs/outputs or register other elements. However, no output stream will be produced until start() method is called.

start()

Smelter.start(): Promise<void>

Starts the processing pipeline. Any previously registered output will start producing the video/audio stream.

registerOutput()

Smelter.registerOutput(
  outputId: string,
  output: RegisterOutput,
): Promise<object>
Type definitions @swmnasion/smelter-node 

import {
  RegisterRtpOutput,
  RegisterMp4Output,
  RegisterWhipOutput
} from "@swmasnion/smelter"


type RegisterOutput =
  | ({ type: 'rtp_stream' } & RegisterRtpOutput)
  | ({ type: 'mp4' } & RegisterMp4Output)
  | ({ type: 'whip' } & RegisterWhipOutput);

Type definitions @swmansion/smelter-web-wasm 

export type RegisterOutput =
  | {
      type: 'stream';
      video: {
        resolution: Api.Resolution;
      };
      audio?: boolean;
    }
  | {
      type: 'canvas';
      video: {
        canvas: HTMLCanvasElement;
        resolution: Api.Resolution;
      };
      audio?: boolean;
    }
  | {
      type: 'whip';
      endpointUrl: string;
      bearerToken?: string;
      iceServers?: RTCConfiguration['iceServers'];
      video: {
        resolution: Api.Resolution;
        maxBitrate?: number;
      };
      audio?: boolean;
    };

Register external destination that can be used as a smelter output. Visit output documentation to learn more.

@swmansion/smelter-node:

@swmansion/smelter-web-wasm

unregisterOutput()

Smelter.unregisterOutput(outputId: string): Promise<void>

Unregister previously registered output.

registerInput()

Smelter.registerInput(
  inputId: string,
  input: RegisterInput
): Promise<object>
Type definitions @swmnasion/smelter-node 

import {
  RegisterRtpInput,
  RegisterMp4Input,
  RegisterWhipInput
} from "@swmasnion/smelter"


type RegisterInput =
  | ({ type: "rtp_stream" } & RegisterRtpInput)
  | ({ type: "mp4" } & RegisterMp4Input)
  | ({ type: "whip" } & RegisterWhipInput);

Type definitions @swmansion/smelter-web-wasm 

type RegisterInput =
  | { type: 'mp4'; url: string }
  | { type: 'camera' }
  | { type: 'screen_capture' }
  | { type: 'stream'; stream: MediaStream };

Register external source that can be used as a smelter input. Visit input documentation to learn more.

@swmansion/smelter-node

@swmansion/smelter-web-wasm

unregisterInput()

Smelter.unregisterInput(inputId: string): Promise<void>

Unregister previously registered input.

registerImage()

import { Renderers } from "@swmansion/smelter"


Smelter.registerImage(
  imageId: string,
  image: Renderers.RegisterImage,
): Promise<void>

Register an image asset. See Renderers.RegisterImage to learn more.

unregisterImage()

Smelter.unregisterImage(imageId: string): Promise<void>

Unregister a previously registered image asset.

registerShader()

import { Renderers } from "@swmnasion/smelter"


Smelter.registerShader(
  shaderId: string,
  shader: Renderers.RegisterShader,
): Promise<void>

Register a shader. See Renderers.RegisterShader to learn more.

unregisterShader()

Smelter.unregisterShader(shaderId: string): Promise<void>

Unregister a previously registered shader.

registerWebRenderer()

import { Renderers } from "@swmansion/smelter"


Smelter.registerWebRenderer(
  instanceId: string,
  instance: Renderers.RegisterWebRenderer,
): Promise<object>

Register a web renderer instance. See Renderers.RegisterWebRenderer to learn more.

unregisterWebRenderer()

Smelter.unregisterWebRenderer(instanceId: string): Promise<void>

Unregister a previously registered web renderer.