_~^~^~_
\) / o o \ (/
'_ - _'
/ '-----' \
🦀 Ferris approves this crate! 🦀
🦀 CrabCamera will be free forever. 🦀 No asterisks. No "free for now." No pivot to paid.
🦀 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 | 63 comprehensive tests 🏆 | No guarantees | Proof-of-concept |
| Memory Safety | Zero unsafe code 🏆 | N/A | Manual management |
- 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.
[dependencies]
crabcamera = "0.1"
tauri = { version = "2.0", features = ["protocol-asset"] }// 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": {}
}
}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
});- 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
- Windows: DirectShow and MediaFoundation backends
- macOS: AVFoundation with Metal acceleration support
- Linux: V4L2 with comprehensive device support
- Unified API: Same code works across all platforms
- Platform Optimization: Best settings for each operating system
- 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
// 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>// 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>// 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<()>// Handle camera permissions properly
request_camera_permission() -> Result<bool>
check_camera_permission_status() -> Result<PermissionStatus>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. 🦀
| 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 | 63 tests passing | No guarantees | Varies |
🦀 Rust Memory Safety + 📷 Camera Hardware = ❤️ Perfect Match
- Rust + Tokio: Memory-safe, async performance
- nokhwa Backend: Cross-platform camera abstraction
- Tauri 2.0 Plugin: Modern plugin architecture
- Platform Backends: DirectShow, AVFoundation, V4L2
- Zero unsafe code: Memory safety guaranteed
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 enum Platform {
Windows,
MacOS,
Linux,
Unknown,
}
// Automatic platform detection
let platform = Platform::current();- 🐛 Bug Reports: GitHub Issues
- 💬 Discussions: GitHub Discussions
- 📖 Documentation: docs.rs/crabcamera
- 💝 Sponsorship: GitHub Sponsors
See our amazing sponsors who make 🦀 CrabCamera possible! 🙏
Sponsorship Tiers:
- $5/month: Coffee tier - My eternal gratitude + sponsor badge
- $25/month: Developer supporter - Priority support + name in SPONSORS.md
- $100/month: Corporate backer - Logo on README + monthly office hours
- $500/month: Enterprise partner - Direct support + feature requests
Companies: Need invoicing? Email michaelallenkuykendall@gmail.com
✅ Ready for production:
- Memory-safe Rust implementation
- 63 comprehensive tests passing
- Zero unsafe code
- Comprehensive error handling
- Async/await throughout
- Cross-platform compatibility verified
✅ Use cases in production:
- Desktop photography applications
- Security and surveillance systems
- Medical imaging interfaces
- Industrial inspection tools
- Educational software platforms
- Communication and streaming apps
// 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);
};// 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);
}MIT License - forever and always.
Philosophy: Desktop applications deserve native camera access. 🦀 CrabCamera is camera infrastructure. 📷
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 📷