Adding `webp_screenshot_rust` library as a dependency

Run this command in a terminal, in your project's directory:

cargo add webp-screenshot-rust

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

webp-screenshot-rust = "1.0.0"

The webp_screenshot_rust library will be automatically available globally. Read the webp_screenshot_rust library documentation.

Back to the crate overview.

Readme

WebP Screenshot Rust

A high-performance, cross-platform screenshot capture library with WebP encoding, written in pure Rust.

Features

🚀 High Performance: SIMD-optimized pixel operations, memory pooling, and zero-copy where possible
🖼️ WebP Encoding: Efficient WebP compression with configurable quality settings
🖥️ Cross-Platform: Windows (GDI/Graphics Capture), macOS (CoreGraphics), Linux (X11/Wayland)
🔧 Hardware Acceleration: Optional GPU acceleration on supported platforms
📊 Multi-Display: Capture from multiple monitors simultaneously
💾 Memory Efficient: Built-in memory pool to reduce allocations
🎯 Flexible API: Simple one-liners or advanced configuration options
🦀 Pure Rust: No C dependencies, safe Rust throughout

Quick Start

Add to your Cargo.toml:

[dependencies]
webp-screenshot-rust = "1.0"

Examples

Simple Capture

use webp_screenshot_rust::WebPScreenshot;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Capture primary display
    let mut screenshot = WebPScreenshot::new()?;
    let result = screenshot.capture_display(0)?;
    result.save("screenshot.webp")?;

    println!("Screenshot saved! Size: {} KB", result.size() / 1024);
    Ok(())
}

Custom Configuration

use webp_screenshot_rust::{WebPScreenshot, CaptureConfig, WebPConfig};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = CaptureConfig {
        webp_config: WebPConfig::high_quality(),
        include_cursor: true,
        use_hardware_acceleration: true,
        ..Default::default()
    };

    let mut screenshot = WebPScreenshot::with_config(config)?;
    let result = screenshot.capture_display(0)?;

    println!("Compression ratio: {:.1}%",
             result.metadata.compression_ratio() * 100.0);
    Ok(())
}

Multi-Display Capture

use webp_screenshot_rust::WebPScreenshot;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut screenshot = WebPScreenshot::new()?;

    // Capture all displays
    let results = screenshot.capture_all_displays();

    for (index, result) in results.iter().enumerate() {
        if let Ok(capture) = result {
            capture.save(&format!("display_{}.webp", index))?;
        }
    }
    Ok(())
}

Performance

Benchmarks on Windows 11 (Intel i7-12700K, 32GB RAM):

Resolution	Capture Time	Encoding Time	WebP Size	Compression
1920x1080	12ms	25ms	145 KB	97.3%
2560x1440	18ms	38ms	256 KB	97.2%
3840x2160	28ms	65ms	512 KB	97.5%

Comparison with Node.js Version

Metric	Node.js/C++	Rust	Improvement
Capture Time	45ms	12ms	73% faster
Memory Usage	150MB	45MB	70% less
Binary Size	25MB	3.5MB	86% smaller
WebP Encoding	95ms	25ms	74% faster

Platform Support

Windows

GDI: Universal support (Windows 7+)
Graphics Capture API: Hardware acceleration (Windows 10 1903+)
Multi-monitor support
HDR capture (with Graphics Capture API)

macOS

CoreGraphics: Universal support (macOS 10.10+)
ScreenCaptureKit: Modern API (macOS 12.3+)
Retina display support
Permission handling

Linux

X11: Traditional desktop support
Wayland: Modern compositor support (optional)
XRandR for multi-monitor
XFixes for cursor capture

Configuration Options

WebP Quality Presets

// Fast encoding, lower quality
let config = WebPConfig::fast();

// Balanced quality/speed
let config = WebPConfig::balanced();

// High quality, slower encoding
let config = WebPConfig::high_quality();

// Lossless compression
let config = WebPConfig::lossless();

Custom WebP Settings

let config = WebPConfig {
    quality: 90,           // 0-100
    method: 4,            // 0-6 (compression effort)
    lossless: false,
    segments: 4,          // 1-4
    sns_strength: 50,     // 0-100
    filter_strength: 60,  // 0-100
    alpha_quality: 100,   // 0-100
    pass: 1,             // 1-10
    thread_count: 0,      // 0 = auto
    ..Default::default()
};

Features

Optional cargo features:

[dependencies]
webp-screenshot-rust = {
    version = "1.0",
    features = ["simd", "parallel", "wayland", "gpu"]
}

simd: Enable SIMD optimizations (default)
parallel: Enable parallel processing (default)
wayland: Linux Wayland support
gpu: GPU acceleration (experimental)
c-api: Build C API for FFI

Building

# Standard build
cargo build --release

# With all features
cargo build --release --all-features

# Run examples
cargo run --example simple_capture
cargo run --example multi_display
cargo run --example streaming

Memory Management

The library includes an intelligent memory pool that:

Reduces allocations by reusing buffers
Automatically manages buffer lifecycle
Provides statistics for monitoring

let screenshot = WebPScreenshot::new()?;
let stats = screenshot.memory_stats();
println!("Buffer hit rate: {:.1}%", stats.hit_rate());

Error Handling

Comprehensive error types with recovery information:

match screenshot.capture_display(0) {
    Ok(result) => { /* success */ },
    Err(CaptureError::PermissionDenied(_)) => {
        // Handle permission error
    },
    Err(e) if e.is_recoverable() => {
        // Retry capture
    },
    Err(e) => {
        // Fatal error
    }
}

Performance Tips

Use memory pooling (enabled by default)
Enable hardware acceleration when available
Choose appropriate quality settings for your use case
Use fast() preset for real-time capture
Batch operations when capturing multiple displays

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

License

MIT License - see LICENSE for details.

Acknowledgments

Original Node.js/C++ implementation by WebP Screenshot Team
webp crate for WebP encoding
image crate for image processing

Migration from Node.js

For users migrating from the Node.js webp-screenshot package:

API is similar but follows Rust conventions
Performance improvements of 20-70% across all operations
Significantly reduced memory usage
No runtime dependencies

See MIGRATION.md for detailed migration guide.

Adding webp_screenshot_rust library as a dependency

Adding `webp_screenshot_rust` library as a dependency