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.
| Workload | Application | Aggregate working set | Private memory | CPU |
|---|---|---|---|---|
| Fresh-launch idle | LeanCast 0.3.0-beta | 53.890 (53.843–54.753) | 31.120 (31.064–31.960) | 0.091% (0.087–0.119%) |
| Fresh-launch idle | OBS 30.1.2 | 115.420 (115.386–115.436) | 150.137 (150.111–150.695) | 0.204% (0.089–0.230%) |
| Matched 720p30 recording | LeanCast 0.3.0-beta | 256.652 (256.618–259.361) | 372.860 (372.280–373.762) | 1.230% (1.141–1.294%) |
| Matched 720p30 recording | OBS 30.1.2 | 282.162 (282.028–282.754) | 399.362 (399.325–401.066) | 1.235% (1.118–1.300%) |
| Dual canvas, four local RTMP destinations | LeanCast 0.3.0-beta | 322.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:
- Summary and comparison JSON
- All trial results: CSV / JSON
- Individual sampled counters
- Native before/after frame counters
- Full decode verification
- Machine, method, media, source, and runtime identity metadata
- Exact measured source snapshot
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:
- 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.
- 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
| Setting | Value |
|---|---|
| Input | Eight-second looping FFmpeg testsrc2 motion pattern, 1280×720, 30 FPS, no input audio |
| Media decoding | OBS ffmpeg_source, software decoding, looping, normal speed |
| Canvas/output | 1280×720 at 30/1 FPS; no rescaling |
| Graphics | Direct3D 11, adapter 0; the NVIDIA GPU on this machine |
| Color | NV12, Rec.709, limited/partial range |
| Video encoder | OBS jim_nvenc, H.264 High, CBR 3,500 Kbps |
| NVENC settings | P3, high-quality tuning, single pass, 2-second keyframe interval, 2 B-frames, lookahead off, psycho-visual tuning off |
| Audio | Silent mixer; FFmpeg AAC, stereo, 48 kHz, 160 Kbps |
| Recording | Local FLV on the same disk |
| Preview | Disabled 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.
- Aggregate working set: sum of
Process.WorkingSet64over the application process family, expressed in MiB (1,048,576 bytes). This is sampled resident process memory. Shared pages can appear in more than one process, so this is not unique physical RAM or the change in total PC memory usage. - Private memory: sum of
Process.PrivateMemorySize64over the process family. This is private allocated memory/Private Bytes, not necessarily resident RAM and not GPU VRAM. Reporting it alongside working set helps reveal paging effects. - CPU: change in process-family processor time divided by wall time and all 16 logical processors, multiplied by 100. A value of 1% means 1% of the machine's total logical CPU capacity, not 1% of one core. Parent and child CPU deltas are included when the process is present in consecutive samples. First-observed CPU and children that start and exit between polls are omitted; measured process families were stable after warmup. The collector and local RTMP server are excluded.
- Frame counters: native snapshots before and after each measured stage. Output FPS is the output-frame delta divided by the native elapsed interval. Render lag is the change in libobs's rendering-lag counter. LeanCast additionally exposes video-output skipped-frame counts; OBS 30.1.2's Lua bindings do not expose that counter, and it is left unavailable rather than reported as zero.
- Statistics: discard the first sample of each measured phase because its CPU interval can overlap warmup. Compute each trial's time-weighted mean over the remaining samples. Publish the median of three trial means and their minimum–maximum range. Retain individual samples and native snapshots for audit.
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 ffprobeIf 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
- OBS launch parameters: portable operation, selected profiles/collections, minimized startup, and bundled modules only.
- OBS 30.1.2 frontend scripting loader: generated collection script configuration.
- OBS 30.1.2 frontend recording API: recording start, stop, active-state and output access.
- OBS 30.1.2 frontend output implementation: recording encoder settings and normal muxer output.
- Microsoft: Process.WorkingSet64, Process.PrivateMemorySize64, and Process.TotalProcessorTime: counter meanings.