Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use cap_recording::{
StudioQuality,
memory_profiling::{CpuTracker, get_process_stats},
screen_capture::ScreenCaptureTarget,
};
use scap_targets::Display;
use std::{
path::{Path, PathBuf},
time::{Duration, Instant},
};
struct RecordingResult {
quality: StudioQuality,
fragmented: bool,
total_duration: Duration,
stop_duration: Duration,
output_path: PathBuf,
screen_size_bytes: u64,
screen_bitrate_mbps: f64,
peak_cpu: f64,
avg_cpu: f64,
peak_rss_mb: f64,
recording_secs: f64,
}
fn dir_size_bytes(path: &Path) -> u64 {
let mut total = 0u64;
if let Ok(entries) = std::fs::read_dir(path) {
for entry in entries.flatten() {
let meta = entry.metadata().ok();
if let Some(m) = meta {
if m.is_file() {
total += m.len();
} else if m.is_dir() {
total += dir_size_bytes(&entry.path());
}
}
}
}
total
}
fn get_screen_size(project_path: &Path, fragmented: bool) -> u64 {
let segment_dir = project_path
.join("content")
.join("segments")
.join("segment-0");
if fragmented {
dir_size_bytes(&segment_dir.join("display"))
} else if let Ok(m) = std::fs::metadata(segment_dir.join("display.mp4")) {
m.len()
} else {
0
}
}
async fn run_recording(
quality: StudioQuality,
fragmented: bool,
duration_secs: u64,
max_fps: u32,
) -> Result<RecordingResult, Box<dyn std::error::Error>> {
let quality_label = match quality {
StudioQuality::Compatibility => "Compatibility",
StudioQuality::Balanced => "Balanced",
StudioQuality::Ultra => "Ultra",
};
let frag_label = if fragmented {
"fragmented"
} else {
"non-fragmented"
};
println!("\n Recording: {quality_label} / {frag_label} / {max_fps}fps / {duration_secs}s");
let mut cpu = CpuTracker::new();
cpu.sample();
let dir = tempfile::tempdir()?;
let builder = cap_recording::studio_recording::Actor::builder(
dir.path().into(),
ScreenCaptureTarget::Display {
id: Display::primary().id(),
},
)
.with_system_audio(false)
.with_fragmented(fragmented)
.with_max_fps(max_fps)
.with_quality(quality);
println!(" Starting...");
let handle = builder
.build(
#[cfg(target_os = "macos")]
Some(cap_recording::SendableShareableContent::from(
cidre::sc::ShareableContent::current()
.await
.expect("Failed to get shareable content"),
)),
)
.await?;
let start = Instant::now();
let sample_interval = Duration::from_secs(2);
let mut next_sample = start + sample_interval;
let mut cpu_samples: Vec<f64> = Vec::new();
let mut peak_rss_mb: f64 = 0.0;
while start.elapsed() < Duration::from_secs(duration_secs) {
tokio::time::sleep(Duration::from_millis(200)).await;
if Instant::now() >= next_sample {
cpu.sample();
let cpu_pct = cpu.latest_cpu_percent().unwrap_or(0.0);
cpu_samples.push(cpu_pct);
if let Some(stats) = get_process_stats() {
if stats.resident_mb > peak_rss_mb {
peak_rss_mb = stats.resident_mb;
}
println!(
" [{:>5.1}s] CPU: {:>5.1}% RSS: {:>6.1} MB",
start.elapsed().as_secs_f64(),
cpu_pct,
stats.resident_mb,
);
}
next_sample = Instant::now() + sample_interval;
}
}
println!(" Stopping...");
let stop_start = Instant::now();
cpu.sample();
let result = handle.stop().await?;
let stop_duration = stop_start.elapsed();
let total_duration = start.elapsed();
cpu.sample();
let recording_secs = total_duration.as_secs_f64();
let screen_size = get_screen_size(&result.project_path, fragmented);
let screen_size_mb = screen_size as f64 / (1024.0 * 1024.0);
let screen_bitrate_mbps = screen_size_mb * 8.0 / recording_secs;
let avg_cpu = if cpu_samples.is_empty() {
0.0
} else {
cpu_samples.iter().sum::<f64>() / cpu_samples.len() as f64
};
let peak_cpu = cpu_samples.iter().copied().fold(0.0f64, f64::max);
println!(" Stop took: {stop_duration:?}");
println!(" Screen: {screen_size_mb:.2} MB ({screen_bitrate_mbps:.2} Mbps)");
std::mem::forget(dir);
Ok(RecordingResult {
quality,
fragmented,
total_duration,
stop_duration,
output_path: result.project_path,
screen_size_bytes: screen_size,
screen_bitrate_mbps,
peak_cpu,
avg_cpu,
peak_rss_mb,
recording_secs,
})
}
fn print_comparison(results: &[RecordingResult]) {
println!("\n{}", "=".repeat(90));
println!(" QUALITY COMPARISON RESULTS");
println!("{}\n", "=".repeat(90));
println!(
"{:<28} {:>10} {:>12} {:>10} {:>10} {:>10} {:>10} {:>10}",
"Mode", "Size (MB)", "Bitrate", "Avg CPU", "Peak CPU", "Peak RSS", "Duration", "Stop Time"
);
println!("{}", "-".repeat(120));
for r in results {
let quality_label = match r.quality {
StudioQuality::Compatibility => "Compatibility",
StudioQuality::Balanced => "Balanced",
StudioQuality::Ultra => "Ultra",
};
let frag_label = if r.fragmented { "frag" } else { "mp4" };
let label = format!("{quality_label} ({frag_label})");
let size_mb = r.screen_size_bytes as f64 / (1024.0 * 1024.0);
println!(
"{:<28} {:>8.2} MB {:>9.2} Mbps {:>8.1}% {:>8.1}% {:>7.1} MB {:>8.1}s {:>10.2?}",
label,
size_mb,
r.screen_bitrate_mbps,
r.avg_cpu,
r.peak_cpu,
r.peak_rss_mb,
r.recording_secs,
r.stop_duration
);
}
println!();
if results.len() >= 2 {
println!("Pairwise comparisons:");
for i in 0..results.len() {
for j in (i + 1)..results.len() {
let a = &results[i];
let b = &results[j];
let a_label = format!(
"{} ({})",
match a.quality {
StudioQuality::Compatibility => "Compatibility",
StudioQuality::Balanced => "Balanced",
StudioQuality::Ultra => "Ultra",
},
if a.fragmented { "frag" } else { "mp4" }
);
let b_label = format!(
"{} ({})",
match b.quality {
StudioQuality::Compatibility => "Compatibility",
StudioQuality::Balanced => "Balanced",
StudioQuality::Ultra => "Ultra",
},
if b.fragmented { "frag" } else { "mp4" }
);
let size_ratio = b.screen_size_bytes as f64 / a.screen_size_bytes.max(1) as f64;
let bitrate_ratio = b.screen_bitrate_mbps / a.screen_bitrate_mbps.max(0.01);
let cpu_diff = b.avg_cpu - a.avg_cpu;
println!(" {b_label} vs {a_label}:");
println!(" Size: {size_ratio:.2}x");
println!(" Bitrate: {bitrate_ratio:.2}x");
println!(
" CPU delta: {}{:.1}%",
if cpu_diff >= 0.0 { "+" } else { "" },
cpu_diff
);
}
}
}
println!();
println!("Output paths:");
for r in results {
let quality_label = match r.quality {
StudioQuality::Compatibility => "Compatibility",
StudioQuality::Balanced => "Balanced",
StudioQuality::Ultra => "Ultra",
};
let frag_label = if r.fragmented { "frag" } else { "mp4" };
println!(
" {quality_label} ({frag_label}): {} (total: {:.1?})",
r.output_path.display(),
r.total_duration
);
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
unsafe { std::env::set_var("RUST_LOG", "info") };
tracing_subscriber::fmt::init();
let args: Vec<String> = std::env::args().collect();
let duration = args
.iter()
.position(|a| a == "--duration")
.and_then(|i| args.get(i + 1))
.and_then(|s| s.parse().ok())
.unwrap_or(10u64);
let max_fps: u32 = args
.iter()
.position(|a| a == "--fps")
.and_then(|i| args.get(i + 1))
.and_then(|s| s.parse().ok())
.unwrap_or(60);
let skip_fragmented = args.contains(&"--no-frag".to_string());
let skip_nonfrag = args.contains(&"--frag-only".to_string());
let display = Display::primary();
let phys = display.physical_size();
let logical = display.logical_size();
println!("=== Cap Quality Comparison Test ===\n");
println!("Duration: {duration}s per recording");
println!("Max FPS: {max_fps}");
println!(
"Display: physical {:?}, logical {:?}",
phys.map(|s| format!("{:.0}x{:.0}", s.width(), s.height())),
logical.map(|s| format!("{:.0}x{:.0}", s.width(), s.height())),
);
println!(
"CPU cores: {}",
std::thread::available_parallelism()
.map(|p| p.get())
.unwrap_or(1)
);
let mut results = Vec::new();
if !skip_nonfrag {
println!("\n{}", "=".repeat(60));
println!(" NON-FRAGMENTED (crash recovery OFF)");
println!("{}", "=".repeat(60));
results.push(run_recording(StudioQuality::Balanced, false, duration, max_fps).await?);
tokio::time::sleep(Duration::from_secs(2)).await;
results.push(run_recording(StudioQuality::Ultra, false, duration, max_fps).await?);
tokio::time::sleep(Duration::from_secs(2)).await;
}
if !skip_fragmented {
println!("\n{}", "=".repeat(60));
println!(" FRAGMENTED (crash recovery ON - default)");
println!("{}", "=".repeat(60));
results.push(run_recording(StudioQuality::Balanced, true, duration, max_fps).await?);
tokio::time::sleep(Duration::from_secs(2)).await;
results.push(run_recording(StudioQuality::Ultra, true, duration, max_fps).await?);
}
print_comparison(&results);
println!("\n=== Quality Comparison Complete ===");
Ok(())
}