🦀 CrabCamera: The Desktop Camera Plugin for Tauri 📷

     __________________________
    < Hello fellow Rustaceans! >
     --------------------------
            \
             \
                _~^~^~_
            \) /  o o  \ (/
              '_   -   _'
              / '-----' \

🦀 CrabCamera will be free forever. 🦀 No asterisks. No "free for now." No pivot to paid.

🦀 What is CrabCamera?

🦀 CrabCamera is the first production-ready desktop camera plugin for Tauri applications. It provides unified camera access across Windows, macOS, and Linux with professional controls and zero-config setup. It's designed to be the invisible infrastructure that makes desktop camera apps just work.

Feature	CrabCamera	Web APIs	Other Plugins
Desktop Native	Windows/macOS/Linux 🏆	Limited browser	Mobile-only
Hardware Access	Direct camera control 🏆	Browser restricted	Basic access
Professional Controls	Auto-focus, exposure 🏆	Limited	Basic
Cross-Platform	Unified API 🏆	Platform dependent	Single platform
Production Ready	157 comprehensive tests 🏆	No guarantees	Proof-of-concept
Memory Safety	Zero unsafe code 🏆	N/A	Manual management

🎯 Perfect for Desktop Applications 🦀

Photography: Photo booth apps, image editors, content creation tools
Security: Surveillance systems, access control, monitoring dashboards
Medical: Imaging interfaces, patient documentation, diagnostic tools
Industrial: Quality control, inspection systems, documentation cameras
Education: Interactive learning tools, virtual labs, presentation software
Communication: Video chat apps, streaming tools, conference software

BONUS: Professional camera controls with platform-optimized settings for maximum image quality.

🦀 Quick Start (30 seconds) 📷

Installation

[dependencies]
crabcamera = "0.4.1"
tauri = { version = "2.0", features = ["protocol-asset"] }

Tauri Integration

// src-tauri/src/main.rs
use crabcamera;

fn main() {
    tauri::Builder::default()
        .plugin(crabcamera::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// tauri.conf.json
{
  "plugins": {
    "crabcamera": {}
  }
}

Frontend Usage

import { invoke } from '@tauri-apps/api/tauri';

// Initialize camera system
await invoke('initialize_camera_system');

// Get available cameras
const cameras = await invoke('get_available_cameras');
console.log('Available cameras:', cameras);

// Get recommended format for high quality
const format = await invoke('get_recommended_format');

// Capture a photo
const photo = await invoke('capture_single_photo', {
  deviceId: cameras[0].id,
  format: format
});

📦 Professional Camera Features 🦀

🔧 Hardware Control 🦀

Device Enumeration: Automatic discovery of all connected cameras
Format Negotiation: Resolution, FPS, and color format selection
Professional Settings: Auto-focus, auto-exposure, white balance
Multi-camera Support: Switch between multiple cameras seamlessly
Error Recovery: Robust handling of device disconnection and errors

🖥️ Cross-Platform Native 🦀

Windows: DirectShow/MediaFoundation with advanced camera controls
macOS: AVFoundation with Metal acceleration support
Linux: V4L2 with comprehensive device support
Unified API: Same code works across all platforms
Professional Controls: Focus, exposure, white balance on all platforms

⚡ Performance & Memory 🦀

Zero-Copy Operations: Minimal memory allocations where possible
Async/Await: Non-blocking operations throughout
Resource Management: Automatic cleanup and device release
Memory Safety: Built with Rust's memory safety guarantees
Thread Safety: Concurrent access with proper synchronization

🔧 Available Commands 🦀

Initialization & Discovery

// Initialize the camera system
initialize_camera_system() -> Result<String>

// Get all available cameras with capabilities
get_available_cameras() -> Result<Vec<CameraDeviceInfo>>

// Get platform-specific information
get_platform_info() -> Result<PlatformInfo>

// Test camera system functionality
test_camera_system() -> Result<SystemTestResult>

Camera Operations

// Check if specific camera is available
check_camera_availability(device_id: String) -> Result<bool>

// Get supported formats for a camera
get_camera_formats(device_id: String) -> Result<Vec<CameraFormat>>

// Get recommended settings for quality photography
get_recommended_format() -> Result<CameraFormat>
get_optimal_settings() -> Result<CameraInitParams>

Capture & Streaming

// Single photo capture
capture_single_photo(device_id: String, format: CameraFormat) -> Result<CameraFrame>

// Photo sequence for burst mode
capture_photo_sequence(params: SequenceParams) -> Result<Vec<CameraFrame>>

// Real-time streaming
start_camera_preview(device_id: String) -> Result<()>
stop_camera_preview() -> Result<()>

// Save frames to disk
save_frame_to_disk(frame: CameraFrame, path: String) -> Result<()>

Professional Camera Controls

// Apply camera controls (focus, exposure, white balance, etc.)
apply_camera_controls(device_id: String, controls: CameraControls) -> Result<()>

// Get current camera control values
get_camera_controls(device_id: String) -> Result<CameraControls>

// Test what controls are supported by camera
test_camera_capabilities(device_id: String) -> Result<CameraCapabilities>

// Get performance metrics
get_camera_performance(device_id: String) -> Result<CameraPerformanceMetrics>

Permissions & Security

// Handle camera permissions properly
request_camera_permission() -> Result<bool>
check_camera_permission_status() -> Result<PermissionStatus>

🦀 Why CrabCamera Will Always Be Free 📷

I built CrabCamera because desktop applications deserve native camera access without the limitations of web APIs or mobile-only plugins.

This is my commitment: CrabCamera stays MIT licensed, forever. If you want to support development, sponsor it. If you don't, just build something incredible with it.

🦀 CrabCamera saves developers weeks of cross-platform camera integration. If it's useful, consider sponsoring for $5/month — less than a coffee, infinitely more valuable than web API limitations. 🦀

📊 Performance Comparison 🦀

Metric	CrabCamera	Web APIs	Mobile Plugins
Desktop Support	Full native	Browser dependent	None
Camera Access	Direct hardware	getUserMedia limited	N/A
Image Quality	Professional controls	Basic settings	Basic
Cross-Platform	Windows/macOS/Linux	Browser variation	iOS/Android only
Performance	Native speed	Browser overhead	N/A
Reliability	157 tests passing	No guarantees	Varies

🏗️ Technical Architecture 🦀

Hybrid Capture + Controls Architecture

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   nokhwa        │    │ Platform Controls│    │  CrabCamera     │
│   (Capture)     │    │ (Advanced)       │    │  (Unified API)  │
├─────────────────┤    ├──────────────────┤    ├─────────────────┤
│ • Frame capture │    │ • Focus control  │    │ • Generic types │
│ • Resolution    │    │ • Exposure       │    │ • Error handling│
│ • Format        │    │ • White balance  │    │ • Cross-platform│
│ • Start/Stop    │    │ • Brightness     │    │ • Thread safety │
└─────────────────┘    └──────────────────┘    └─────────────────┘

Platform-Specific Implementations

Windows: nokhwa capture + MediaFoundation controls
macOS: AVFoundation for both capture and controls
Linux: nokhwa capture + V4L2 controls
Unified API: Same control interface across all platforms

Key Technologies

Rust + Tokio: Memory-safe, async performance
Tauri 2.0 Plugin: Modern plugin architecture
Platform Backends: MediaFoundation, AVFoundation, V4L2
COM Interface Management: Thread-safe Windows controls
Zero unsafe code: Memory safety guaranteed (except platform COM interfaces)

📚 API Reference 🦀

Core Types

pub struct CameraDeviceInfo {
    pub id: String,
    pub name: String,
    pub description: String,
    pub is_available: bool,
    pub supports_formats: Vec<CameraFormat>,
}

pub struct CameraFormat {
    pub width: u32,
    pub height: u32,
    pub fps: f32,
    pub format_type: String, // "RGB8", "JPEG", etc.
}

pub struct CameraFrame {
    pub data: Vec<u8>,
    pub width: u32,
    pub height: u32,
    pub format: String,
    pub timestamp: DateTime<Utc>,
}

pub struct CameraControls {
    pub auto_focus: Option<bool>,
    pub focus_distance: Option<f32>,     // 0.0 = infinity, 1.0 = closest
    pub auto_exposure: Option<bool>,
    pub exposure_time: Option<f32>,      // seconds
    pub white_balance: Option<WhiteBalance>,
    pub brightness: Option<f32>,         // -1.0 to 1.0
    pub contrast: Option<f32>,           // -1.0 to 1.0
    pub saturation: Option<f32>,         // -1.0 to 1.0
}

pub struct CameraCapabilities {
    pub supports_auto_focus: bool,
    pub supports_manual_focus: bool,
    pub supports_auto_exposure: bool,
    pub supports_manual_exposure: bool,
    pub supports_white_balance: bool,
    pub focus_range: Option<(f32, f32)>,
    pub exposure_range: Option<(f32, f32)>,
}

Platform Detection

pub enum Platform {
    Windows,
    MacOS,
    Linux,
    Unknown,
}

// Automatic platform detection
let platform = Platform::current();

🦀 Community & Support 📷

🐛 Bug Reports: GitHub Issues
💬 Discussions: GitHub Discussions
📖 Documentation: docs.rs/crabcamera
💝 Sponsorship: GitHub Sponsors

Governance

CrabCamera is open source, not open contribution. The code is freely available under the MIT license, but pull requests are not accepted by default. See CONTRIBUTING.md for details.

This model ensures consistent quality across all platforms and clear project direction.

🚀 Production Usage 🦀

✅ Ready for production:

Memory-safe Rust implementation
157 comprehensive tests passing
Zero unsafe code
Comprehensive error handling
Async/await throughout
Cross-platform compatibility verified
Real hardware validation (OBSBOT Tiny 4K)

✅ Use cases in production:

Desktop photography applications
Security and surveillance systems
Medical imaging interfaces
Industrial inspection tools
Educational software platforms
Communication and streaming apps

💡 Examples & Integration 🦀

Photo Booth Application

// Simple photo booth with camera selection
const cameras = await invoke('get_available_cameras');
const selectedCamera = cameras[0];
const format = await invoke('get_recommended_format');

// Take photo when user clicks
document.getElementById('capture').onclick = async () => {
    const photo = await invoke('capture_single_photo', {
        deviceId: selectedCamera.id,
        format: format
    });
    // Display photo in UI
    displayPhoto(photo);
};

Multi-Camera Security System

// Monitor multiple cameras
const cameras = await invoke('get_available_cameras');
for (const camera of cameras) {
    await invoke('start_camera_preview', { deviceId: camera.id });
    // Set up streaming handlers for each camera
    setupCameraStream(camera);
}

📜 License & Philosophy 🦀

MIT License - forever and always.

Philosophy: Desktop applications deserve native camera access. 🦀 CrabCamera is camera infrastructure. 📷

🚀 What's New in v0.4.x

🎉 v0.4.1: Bug Fixes, Performance & DX (December 2025)

Critical Fix: Mock camera was incorrectly used during cargo run - now uses real cameras
PNG Save Fixed: save_frame_to_disk() now properly encodes PNG/JPEG instead of raw bytes
Performance: Camera warmup reduced from 10 frames to 5 frames (~250ms faster)
macOS Fixed: Objective-C block syntax and nokhwa API compatibility resolved
DX Improvement: New get_system_diagnostics() command for troubleshooting
Test Suite: 157 tests passing (up from 80) with real hardware validation
Flaky Test Fixed: test_capture_performance timeout increased for reliability

🎉 v0.4.0: Quality Intelligence & Configuration

Quality Validation: Automatic blur/exposure detection with retry
TOML Configuration: Full runtime config with hot-reload
Focus Stacking: Computational photography for macro shots
Device Monitoring: Hot-plug detection for camera connect/disconnect

🎉 v0.3.0: Windows MediaFoundation Camera Controls

Professional Windows Controls: Full focus, exposure, white balance, brightness, contrast, and saturation control
Hybrid Architecture: nokhwa capture + MediaFoundation controls for best of both worlds
Thread-Safe COM: Proper Windows COM interface management for Tauri async commands
Capability Detection: Runtime testing of which controls each camera supports
Unified API: Same control interface across Windows, macOS, and Linux

🔧 Technical Improvements

WindowsCamera Struct: Combines nokhwa capture with MediaFoundation controls
MediaFoundationControls: Full COM interface wrapper with resource management
Platform Integration: Updated PlatformCamera enum to use Windows-specific implementation
Error Handling: Graceful degradation when controls aren't supported
Documentation: Comprehensive technical architecture documentation

🏆 Cross-Platform Parity Achieved

Windows users now get the same professional camera control experience as macOS and Linux users!

Forever maintainer: Michael A. Kuykendall
Promise: This will never become a paid product
Mission: Making desktop camera development effortless

"🦀 Native performance. Cross-platform compatibility. Zero hassle. 📷"

       🦀🦀🦀 Happy Coding! 🦀🦀🦀
          Made with ❤️ and Rust
           📷 Capture the moment 📷

crabcamera 0.4.1