Output formats and codecs

Helios supports a wide range of output formats and codecs through FFmpeg and WebCodecs, allowing you to optimize for quality, file size, or compatibility.

Video containers

MP4

Most widely supported container format:

const renderer = new Renderer({
  videoCodec: 'libx264',
  pixelFormat: 'yuv420p'
});

await renderer.render(url, './output.mp4');

Compatible codecs:

H.264 (libx264, h264_nvenc, h264_qsv, h264_videotoolbox)
H.265 (libx265, hevc_nvenc, hevc_qsv, hevc_videotoolbox)
AV1 (libaom-av1, libsvtav1)

WebM

Open source container for web delivery:

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  audioCodec: 'libvorbis'
});

await renderer.render(url, './output.webm');

Compatible codecs:

VP8 (libvpx)
VP9 (libvpx-vp9)
AV1 (libaom-av1)

MOV

QuickTime format, useful for intermediate files:

const renderer = new Renderer({
  videoCodec: 'prores',
  audioCodec: 'pcm_s16le'
});

await renderer.render(url, './output.mov');

Compatible codecs:

ProRes (prores, prores_ks)
DNxHD (dnxhd)
PCM audio (pcm_s16le, pcm_s24le)

Video codecs

H.264 (libx264)

Best compatibility and hardware support:

const renderer = new Renderer({
  videoCodec: 'libx264',
  preset: 'medium',
  crf: 23,  // 0-51, lower = better quality
  pixelFormat: 'yuv420p'
});

preset

string

default:"'medium'"

Encoding speed vs compression ratio:

'ultrafast': Fastest encoding, largest file
'superfast', 'veryfast', 'faster', 'fast'
'medium': Balanced
'slow', 'slower', 'veryslow': Smaller file, slower encoding

crf

number

default:"23"

Constant Rate Factor (quality):

0: Lossless (huge files)
18-23: High quality (recommended)
23-28: Good quality
28-35: Lower quality (smaller files)
51: Lowest quality

tune

string

Optimize for specific content:

'film': Feature film content
'animation': Animated content
'grain': Preserve grain
'stillimage': Slideshow content

H.265 (libx265)

Better compression than H.264, but slower encoding:

const renderer = new Renderer({
  videoCodec: 'libx265',
  preset: 'medium',
  crf: 28,  // Use higher CRF than H.264 for similar quality
  pixelFormat: 'yuv420p'
});

H.265 achieves similar quality to H.264 at ~50% smaller file size, but:

Encoding is 5-10x slower
Requires modern players (may not work on older devices)
Patent licensing issues in some regions

VP9 (libvpx-vp9)

Royalty-free codec for web delivery:

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  crf: 30,
  videoBitrate: '2M',  // Target bitrate
  audioCodec: 'libvorbis'
});

await renderer.render(url, './output.webm');

VP9 options:

Similar quality to H.265
Better than H.264 at low bitrates
Native support in all modern browsers
Slower encoding than H.264

AV1 (libaom-av1)

Next-generation codec with best compression:

const renderer = new Renderer({
  videoCodec: 'libaom-av1',
  crf: 30,
  preset: 'fast',  // AV1 encoding is VERY slow
  pixelFormat: 'yuv420p'
});

AV1 encoding is extremely slow. A 10-second 1080p video can take 30+ minutes even on fast hardware. Use only when file size is critical.

Consider using libsvtav1 for faster AV1 encoding:

const renderer = new Renderer({
  videoCodec: 'libsvtav1',
  crf: 30,
  preset: '8'  // 0-13, higher = faster
});

Hardware-accelerated codecs

NVIDIA NVENC

Fast encoding on NVIDIA GPUs:

const renderer = new Renderer({
  hwAccel: 'cuda',
  videoCodec: 'h264_nvenc',
  preset: 'p4',  // p1-p7, higher = better quality
  videoBitrate: '5M'
});

NVENC presets:

'p1': Fastest
'p4': Balanced
'p7': Best quality

Also available: hevc_nvenc for H.265

Intel Quick Sync (QSV)

Hardware encoding on Intel CPUs:

const renderer = new Renderer({
  hwAccel: 'qsv',
  videoCodec: 'h264_qsv',
  preset: 'medium'
});

Also available: hevc_qsv, vp9_qsv

Apple VideoToolbox

Hardware encoding on macOS:

const renderer = new Renderer({
  hwAccel: 'videotoolbox',
  videoCodec: 'h264_videotoolbox',
  videoBitrate: '5M'
});

Also available: hevc_videotoolbox, prores_videotoolbox

AMD VCE/VCN

Hardware encoding on AMD GPUs:

const renderer = new Renderer({
  hwAccel: 'vaapi',  // On Linux
  videoCodec: 'h264_vaapi'
});

Audio codecs

AAC

Most compatible audio codec:

const renderer = new Renderer({
  audioCodec: 'aac',
  audioBitrate: '192k'  // 128k, 192k, 256k, 320k
});

Recommended bitrates:

'128k': Good quality
'192k': High quality (recommended)
'256k': Very high quality
'320k': Maximum quality (overkill for most uses)

Opus

Best quality per bitrate for WebM:

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  audioCodec: 'libopus',
  audioBitrate: '128k'
});

Opus is more efficient than AAC at the same bitrate.

Vorbis

Open source codec for WebM:

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  audioCodec: 'libvorbis',
  audioBitrate: '192k'
});

PCM (uncompressed)

Lossless audio for intermediate files:

const renderer = new Renderer({
  audioCodec: 'pcm_s16le'  // 16-bit PCM
});

Also available:

'pcm_s24le': 24-bit PCM (higher quality)
'pcm_s32le': 32-bit PCM
'pcm_f32le': 32-bit float PCM

Pixel formats

yuv420p

Standard format, widest compatibility:

const renderer = new Renderer({
  pixelFormat: 'yuv420p'
});

Limitations:

No alpha channel
4:2:0 chroma subsampling

yuv444p

Full chroma resolution:

const renderer = new Renderer({
  pixelFormat: 'yuv444p'
});

Benefits:

No chroma subsampling
Better color fidelity
Larger file size

yuva420p

With alpha channel:

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  pixelFormat: 'yuva420p'
});

Alpha channel requires specific codecs (VP8, VP9, PNG). H.264 does not support alpha.

Common presets

High quality for archival

const renderer = new Renderer({
  videoCodec: 'libx265',
  preset: 'slow',
  crf: 18,
  pixelFormat: 'yuv420p',
  audioCodec: 'aac',
  audioBitrate: '256k'
});

Fast encoding for previews

const renderer = new Renderer({
  videoCodec: 'libx264',
  preset: 'ultrafast',
  crf: 28,
  audioCodec: 'aac',
  audioBitrate: '128k'
});

Web optimized (small file size)

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  crf: 32,
  videoBitrate: '1M',
  audioCodec: 'libopus',
  audioBitrate: '96k'
});

await renderer.render(url, './output.webm');

Hardware accelerated (NVIDIA)

const renderer = new Renderer({
  hwAccel: 'cuda',
  videoCodec: 'h264_nvenc',
  preset: 'p4',
  videoBitrate: '5M',
  audioCodec: 'aac',
  audioBitrate: '192k'
});

Transparent video

const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  pixelFormat: 'yuva420p',
  mode: 'canvas',
  intermediateVideoCodec: 'vp8',  // VP8 supports alpha
  audioCodec: 'libvorbis'
});

await renderer.render(url, './output.webm');

Stream copy mode

Skip re-encoding for faster processing:

const renderer = new Renderer({
  videoCodec: 'copy',  // Copy video stream without re-encoding
  mode: 'canvas',
  intermediateVideoCodec: 'avc1.4d002a'  // Must match final codec
});

When using videoCodec: 'copy', the intermediate codec must match the desired output codec. WebCodecs must be enabled (canvas mode).

Use stream copy when:

Adding/removing audio tracks
Trimming video
Changing container format

Do not use when:

Changing resolution
Changing codec
Burning in subtitles

Bitrate control

Constant Rate Factor (CRF)

Quality-based encoding:

const renderer = new Renderer({
  videoCodec: 'libx264',
  crf: 23  // Target quality, file size varies
});

Best for:

Variable content complexity
Archival
When quality is more important than file size

Constant Bitrate (CBR)

Fixed bitrate:

const renderer = new Renderer({
  videoCodec: 'libx264',
  videoBitrate: '5M'  // Exact bitrate, quality varies
});

Best for:

Streaming
Predictable file sizes
Broadcast requirements

Two-pass encoding

For CBR, FFmpeg can use two-pass encoding (not currently exposed in Helios API):

# Pass 1
ffmpeg -i input.mp4 -c:v libx264 -b:v 5M -pass 1 -f null /dev/null

# Pass 2
ffmpeg -i input.mp4 -c:v libx264 -b:v 5M -pass 2 output.mp4

Format recommendations

For web delivery

// Modern browsers
const renderer = new Renderer({
  videoCodec: 'libvpx-vp9',
  crf: 30,
  audioCodec: 'libopus',
  audioBitrate: '128k'
});
await renderer.render(url, './output.webm');

// Instagram, TikTok, YouTube
const renderer = new Renderer({
  width: 1080,
  height: 1920,  // Vertical video
  videoCodec: 'libx264',
  preset: 'medium',
  crf: 23,
  pixelFormat: 'yuv420p',
  audioCodec: 'aac',
  audioBitrate: '192k'
});

For broadcast/professional

// ProRes for editing
const renderer = new Renderer({
  videoCodec: 'prores_ks',
  profile: 2,  // ProRes 422
  audioCodec: 'pcm_s24le'
});
await renderer.render(url, './output.mov');

For maximum compatibility

// Works everywhere, including old devices
const renderer = new Renderer({
  videoCodec: 'libx264',
  preset: 'medium',
  crf: 23,
  pixelFormat: 'yuv420p',
  audioCodec: 'aac',
  audioBitrate: '128k'
});
await renderer.render(url, './output.mp4');

Get Started

Core Concepts

Framework Guides

Features

Rendering

Tools

Component Registry

Advanced

​Video containers

​MP4

​WebM

​MOV

​Video codecs

​H.264 (libx264)

​H.265 (libx265)

​VP9 (libvpx-vp9)

​AV1 (libaom-av1)

​Hardware-accelerated codecs

​NVIDIA NVENC

​Intel Quick Sync (QSV)

​Apple VideoToolbox

​AMD VCE/VCN

​Audio codecs

​AAC

​Opus

​Vorbis

​PCM (uncompressed)

​Pixel formats

​yuv420p

​yuv444p

​yuva420p

​Common presets

​High quality for archival

​Fast encoding for previews

​Web optimized (small file size)

​Hardware accelerated (NVIDIA)

​Transparent video

​Stream copy mode

​Bitrate control

​Constant Rate Factor (CRF)

​Constant Bitrate (CBR)

​Two-pass encoding

​Format recommendations

​For web delivery

​For social media

​For broadcast/professional

​For maximum compatibility

Build docs developers (and LLMs) love

Video containers

MP4

WebM

MOV

Video codecs

H.264 (libx264)

H.265 (libx265)

VP9 (libvpx-vp9)

AV1 (libaom-av1)

Hardware-accelerated codecs

NVIDIA NVENC

Intel Quick Sync (QSV)

Apple VideoToolbox

AMD VCE/VCN

Audio codecs

AAC

Opus

Vorbis

PCM (uncompressed)

Pixel formats

yuv420p

yuv444p

yuva420p

Common presets

High quality for archival

Fast encoding for previews

Web optimized (small file size)

Hardware accelerated (NVIDIA)

Transparent video

Stream copy mode

Bitrate control

Constant Rate Factor (CRF)

Constant Bitrate (CBR)

Two-pass encoding

Format recommendations

For web delivery

For social media

For broadcast/professional

For maximum compatibility