Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
mod audio;
mod cameras;
mod displays;
pub use audio::*;
pub use cameras::*;
pub use displays::*;
use anyhow::Result;
use colored::Colorize;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiscoveredHardware {
pub displays: Vec<DiscoveredDisplay>,
pub cameras: Vec<DiscoveredCamera>,
pub audio_inputs: Vec<DiscoveredAudioInput>,
pub audio_outputs: Vec<DiscoveredAudioOutput>,
pub system_info: SystemInfo,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemInfo {
pub platform: String,
pub os_version: String,
pub cpu: String,
pub memory_gb: u64,
pub gpu: Option<String>,
}
impl DiscoveredHardware {
pub async fn discover() -> Result<Self> {
let displays = discover_displays()?;
let cameras = discover_cameras()?;
let (audio_inputs, audio_outputs) = discover_audio_devices()?;
let system_info = discover_system_info();
Ok(Self {
displays,
cameras,
audio_inputs,
audio_outputs,
system_info,
})
}
pub fn print_summary(&self) {
println!("\n{}", "=== Hardware Discovery ===".bold().cyan());
println!("\n{}", "System Info:".bold());
println!(" Platform: {}", self.system_info.platform);
println!(" OS Version: {}", self.system_info.os_version);
println!(" CPU: {}", self.system_info.cpu);
println!(" Memory: {} GB", self.system_info.memory_gb);
if let Some(gpu) = &self.system_info.gpu {
println!(" GPU: {gpu}");
}
println!("\n{} ({})", "Displays:".bold(), self.displays.len());
for display in &self.displays {
println!(
" {} - {}x{} @ {:.0}Hz",
display.name.as_deref().unwrap_or("Unknown"),
display.physical_width,
display.physical_height,
display.refresh_rate
);
}
println!("\n{} ({})", "Cameras:".bold(), self.cameras.len());
for camera in &self.cameras {
let formats_str = camera
.formats
.iter()
.take(3)
.map(|f| format!("{}x{}@{}fps", f.width, f.height, f.frame_rate))
.collect::<Vec<_>>()
.join(", ");
let suffix = if camera.formats.len() > 3 {
format!(" +{} more", camera.formats.len() - 3)
} else {
String::new()
};
println!(" {} - {}{}", camera.name, formats_str, suffix);
}
println!("\n{} ({})", "Audio Inputs:".bold(), self.audio_inputs.len());
for input in &self.audio_inputs {
let device_type = if input.is_bluetooth {
" [Bluetooth]"
} else if input.is_usb {
" [USB]"
} else {
""
};
println!(
" {} - {}Hz, {} ch{}",
input.name,
input.sample_rates.first().unwrap_or(&0),
input.channels,
device_type
);
}
println!(
"\n{} ({})",
"Audio Outputs:".bold(),
self.audio_outputs.len()
);
for output in &self.audio_outputs {
println!(
" {} - {}Hz, {} ch",
output.name,
output.sample_rates.first().unwrap_or(&0),
output.channels
);
}
println!();
}
}
fn discover_system_info() -> SystemInfo {
use sysinfo::System;
let mut sys = System::new_all();
sys.refresh_all();
let cpu = sys
.cpus()
.first()
.map(|c| c.brand().to_string())
.unwrap_or_else(|| "Unknown".to_string());
let memory_gb = sys.total_memory() / 1024 / 1024 / 1024;
let platform = if cfg!(target_os = "macos") {
"macOS".to_string()
} else if cfg!(target_os = "windows") {
"Windows".to_string()
} else {
"Unknown".to_string()
};
let os_version = detect_os_version();
let gpu = detect_gpu();
SystemInfo {
platform,
os_version,
cpu,
memory_gb,
gpu,
}
}
#[cfg(target_os = "macos")]
fn detect_os_version() -> String {
std::process::Command::new("sw_vers")
.arg("-productVersion")
.output()
.ok()
.and_then(|output| {
if output.status.success() {
String::from_utf8(output.stdout)
.ok()
.map(|s| format!("macOS {}", s.trim()))
} else {
None
}
})
.unwrap_or_else(|| "macOS (unknown version)".to_string())
}
#[cfg(target_os = "windows")]
fn detect_os_version() -> String {
std::process::Command::new("cmd")
.args(["/C", "ver"])
.output()
.ok()
.and_then(|output| {
if output.status.success() {
String::from_utf8(output.stdout)
.ok()
.map(|s| s.trim().to_string())
} else {
None
}
})
.unwrap_or_else(|| "Windows (unknown version)".to_string())
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
fn detect_os_version() -> String {
"Unknown OS".to_string()
}
#[cfg(target_os = "macos")]
fn detect_gpu() -> Option<String> {
Some("Apple Silicon / Intel UHD".to_string())
}
#[cfg(target_os = "windows")]
fn detect_gpu() -> Option<String> {
None
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
fn detect_gpu() -> Option<String> {
None
}