LeanCast benchmark methods and results

This benchmark measures LeanCast 0.3.0-beta on one Windows laptop using generated video. It is evidence about the tested configuration, not a promise of gaming FPS, lower latency, universal hardware performance, or successful delivery to a streaming platform. TikTok LIVE Studio was not measured.

On the tested laptop, LeanCast's matched 720p30 recording used 9.0% less aggregate process working set and 6.6% less private allocated memory than OBS. Active CPU measured 1.230% versus 1.235% of total logical CPU capacity, with overlapping trial ranges. These measurements describe this short synthetic workload, not a general CPU-speedup or gameplay-performance claim.

Results — October 7, 2026

Values below are the median of three trial means; parentheses show the minimum–maximum trial mean. Memory is MiB. CPU is normalized across all 16 logical processors.

WorkloadApplicationAggregate working setPrivate memoryCPU
Fresh-launch idleLeanCast 0.3.0-beta53.890 (53.843–54.753)31.120 (31.064–31.960)0.091% (0.087–0.119%)
Fresh-launch idleOBS 30.1.2115.420 (115.386–115.436)150.137 (150.111–150.695)0.204% (0.089–0.230%)
Matched 720p30 recordingLeanCast 0.3.0-beta256.652 (256.618–259.361)372.860 (372.280–373.762)1.230% (1.141–1.294%)
Matched 720p30 recordingOBS 30.1.2282.162 (282.028–282.754)399.362 (399.325–401.066)1.235% (1.118–1.300%)
Dual canvas, four local RTMP destinationsLeanCast 0.3.0-beta322.020 (320.566–322.756)533.535 (532.171–534.850)1.377% (1.323–1.482%)

Fresh-launch idle working set was 53.3% less than OBS. Its native-engine states differ intentionally, as described below; this is not an initialized-pipeline comparison. The dual-canvas row has no equivalent OBS result and must not be compared against OBS's single-encode row as a like-for-like efficiency claim.

The active measured stages reported 0 total rendering-lag frames. Output throughput across these cases ranged from 29.950 to 30.035 FPS. LeanCast's reported video-output skipped-frame counts were 0, 0, 0, 0, 0, 0 for its active trials. That skipped-frame counter is unavailable through the OBS Lua bindings used here. Native output identities confirmed two shared video encoders and one shared AAC encoder for each four-route trial.

All 18 retained synthetic files passed full audio/video decoding without reported errors. The six matched recordings contained H.264 High 1280×720 at 30 FPS. Each four-route sample set contained three landscape H.264 streams and one 720×1280 portrait stream; all files contained AAC stereo at 48 kHz. No platform delivery or live application capture is implied by those file checks.

Test machine: AMD Ryzen 9 5900HS, 8 cores/16 logical processors; NVIDIA GeForce RTX 3050 Ti Laptop GPU (driver 32.0.16.1714); 16 GB nominal RAM (15.41 GiB visible to Windows); Windows 11 Home build 10.0.26300. OBS identified the NVIDIA device as Direct3D adapter 0. The AMD integrated GPU was also present. At inventory time approximately 1.89 GiB of physical memory was available. Background whole-system CPU activity varied; it was recorded rather than hidden or attributed to either application.

Public evidence:

All 63 DLL/EXE files in the copied OBS binary/plugin directories matched the original installation by SHA-256. The earlier prototype benchmark and smoke tests are excluded. This is a fresh three-trial run after the general scene/editor/hotkey work. The collector includes a correction, made before this run, for an integer-overload defect found during an earlier prototype measurement. No earlier measurements contribute to this release table.

Matched comparison

The test compares the real LeanCast WinForms frontend with OBS Studio 30.1.2. Both frontends are minimized with preview disabled. LeanCast is compiled with a small benchmark entry point that instantiates MainForm(false), preserving the real UI and its status timer while avoiding saved profiles. OBS runs from a separate portable copy with a generated profile and scene collection. The user's existing OBS profiles and recordings are neither read nor changed. OBS loads its bundled modules; third-party plugins are disabled. LeanCast loads its normal module allowlist. These differences in application design are part of the measurement.

Each matched trial has two stages:

  1. Fresh-launch application idle: five seconds of warmup, then twenty measured seconds. LeanCast has not initialized its native media engine. OBS has initialized its normal media engine and an empty scene, with no capture sources. This compares the apps' natural idle behavior; it does not claim identical initialized pipelines. LeanCast may retain additional native-library memory after stopping a capture, so the idle result must not be described as its memory after a streaming session.
  2. Single local recording: the same generated moving video, five seconds of recording warmup, then twenty measured seconds. Both render and encode a full 1280×720 canvas at 30 FPS using identical settings. This stage provides the matched active-workload comparison.

Three trials per app alternate in the order LeanCast/OBS, OBS/LeanCast, LeanCast/OBS. Only one benchmark application runs at a time. Unrelated apps remain open; the harness never closes them. Other development builds and test encodes were held during the final measurement window.

Identical active-workload settings

SettingValue
InputEight-second looping FFmpeg testsrc2 motion pattern, 1280×720, 30 FPS, no input audio
Media decodingOBS ffmpeg_source, software decoding, looping, normal speed
Canvas/output1280×720 at 30/1 FPS; no rescaling
GraphicsDirect3D 11, adapter 0; the NVIDIA GPU on this machine
ColorNV12, Rec.709, limited/partial range
Video encoderOBS jim_nvenc, H.264 High, CBR 3,500 Kbps
NVENC settingsP3, high-quality tuning, single pass, 2-second keyframe interval, 2 B-frames, lookahead off, psycho-visual tuning off
AudioSilent mixer; FFmpeg AAC, stereo, 48 kHz, 160 Kbps
RecordingLocal FLV on the same disk
PreviewDisabled in both applications

OBS uses its normal ffmpeg_muxer recording output, including its helper process. LeanCast uses its normal native FLV output. Both encode the same media settings, but the muxer implementations differ. CPU and memory totals include descendants of the measured application, so the OBS muxer helper is included.

Four-destination workload

The separate LeanCast-only workload uses the same motion source in a landscape scene and a 720×1280 portrait scene. Three 1280×720 destinations share one NVENC encoder; one 720×1280 destination uses a second NVENC encoder. All four share a single AAC encoder. Both video encoders use the settings above. The synthetic content is fitted within the portrait canvas without cropping.

All four outputs send to a minimal RTMP sink bound exclusively to 127.0.0.1; credentials are synthetic. There is no public stream, camera, microphone, display or window capture, or real account access. The sink confirms receipt and saves the first few seconds for independent decoding. The sink's Node.js process is excluded from application resource totals, since it represents the receiving server; it remains a small additional load on the test machine.

This workload also has three trials, each with five seconds of warmup and twenty measured seconds. Native encoder identities are checked to prove two active video encoders and one active AAC encoder. The default OBS frontend does not provide this exact dual-canvas/four-output configuration without additional tooling, so there is no matched OBS comparison for this row.

Measurement and interpretation

The collector samples the benchmark-owned process and its descendants approximately every 500 ms. It checks the executable path before terminating only its own portable OBS process. Recording is stopped through the official OBS Lua frontend API and confirmed inactive before termination. LeanCast stops its outputs and disposes the engine normally.

The laptop had other applications open and limited free memory. Whole-system CPU use and available physical memory are retained in the samples. Background load, scheduling, power management, driver state, and paging can affect results. These short trials do not establish long-session stability, thermals, game performance, capture compatibility, network reliability, or streaming-service acceptance. No total-PC power, VRAM, upload bandwidth, or end-to-end latency comparison was measured.

The published metadata identifies the exact benchmark executable, engine, tested source files, generated media, and matching installed/portable OBS binaries by SHA-256. The included snapshot preserves the exact application sources and benchmark harness used for these measurements. The benchmark entry point differs from the normal executable entry point so it can inject generated media without opening saved profiles or physical sources. Custom background photographs, physical cameras, microphone capture, and live scene switching are outside this performance workload; functional scene/pause checks are documented separately.

Reproduce

Requirements: Windows x64, OBS Studio 30.1.2 installed, compatible NVENC hardware, the Windows .NET Framework C# compiler, PowerShell, Node.js, and an FFmpeg distribution containing both ffmpeg and ffprobe. Install those tools separately; this repository does not redistribute the copied OBS runtime or generated recordings. The tested recipe intentionally fails if its portable OBS copy is not version 30.1.2. Other GPUs or encoder implementations require a separate, explicitly labeled recipe.

From the source directory, with ffmpeg, ffprobe, and node on PATH:

.\benchmarks\run-benchmarks.ps1 -UseMeasuredSnapshot -Trials 3 -SampleSeconds 20 -WarmupSeconds 5 -RunName local-test
node .\benchmarks\analyze-benchmarks.cjs .\benchmarks\results\local-test
node .\benchmarks\verify-recordings.cjs .\benchmarks\results\local-test ffmpeg ffprobe

If tools are not on PATH, pass -ObsPath, -FfmpegPath, and -NodePath to the PowerShell script and explicit FFmpeg/FFprobe paths to the verifier. Use a new RunName for every run. The script creates only an isolated benchmarks/runtime copy/configuration and files beneath benchmarks/results. It does not save the user's profiles or credentials. Keep raw runtime logs, copied binaries, generated media, and intermediate results out of public releases. The analysis script exports only public metrics to benchmarks/published.

-UseMeasuredSnapshot compiles the exact measured application sources and harness preserved under benchmarks/snapshot. Omit it to benchmark the current public sources, and label that as a new result. The compiler can produce a different executable hash on another build; source hashes and settings identify the preserved configuration.

Run the decoding verifier after the measured workloads; otherwise its CPU load would contaminate the measurement. A passing verification checks H.264 dimensions and 30 FPS, AAC 48 kHz stereo, and complete error-free decoding of every retained file. Sink samples contain only the first approximately three seconds; local recordings contain the whole warmup plus measured stage and final flush.

Primary references

Back to LeanCast · Download this document