RustFrame is a privacy-focused, cross-platform screen region sharing tool. It lets you select any area of your screen and share only that region in video calls—without exposing your entire desktop.

What does RustFrame do?

• Lets you share a specific part of your screen (not the whole desktop)
• Works with all major video conferencing apps (Google Meet, Zoom, Teams, Discord)
• Supports multi-monitor setups and ultra-wide screens
• Keeps your private info hidden—share only what you want
• Fast and lightweight: minimal CPU/memory usage, instant region adjustment
• No account, no cloud, no telemetry—everything runs locally

Key Features:

• Pixel-perfect region selection with a draggable border
• Real-time preview window (“RustFrame - Share this window”) for sharing
• Move/resize the capture region live—even while sharing
• GPU-accelerated for smooth performance
• Customizable: border, highlights, cursor, FPS, and more
• Multi-language UI with downloadable language packs
• Windows, macOS, and Linux support (Linux experimental)

See below for quick links and platform details. For more, see the User Guide.

• Download Latest Release
• User Guide – Installation, usage, troubleshooting
• Quick Start – Get started in 30 seconds
• Developer Guide – Architecture, building, contributing
• Technical Docs – Platform details, performance, internals
• Profiles & Platform Settings – Platform-specific configuration

Language	Video
English
Turkish

RustFrame needs OS permissions to capture the screen and may be blocked by platform security defaults. If you hit permission prompts or the app will not open, check these docs:

• macOS: Screen Recording + Accessibility are required; Gatekeeper may require "Open Anyway." See docs/user-guide/macos-permissions.md.
• Windows: No OS permission prompts, but some capture methods may require admin-level graphics access; see docs/user-guide/troubleshooting.md if capture fails.

RustFrame is designed for:

• Precise region capture with pixel-perfect control
• Multi-monitor support and auto-detection
• Content filtering (include/exclude apps/windows)
• GPU-accelerated performance
• Customizable UI (borders, highlights, cursor, FPS)
• Cross-platform: Windows, macOS, Linux (experimental)

See docs/README.md for full documentation structure and navigation.

RustFrame supports per-app capture profiles. On Windows, you typically need a specific profile so the window picker can see RustFrame. On macOS, the default profile works for native apps; use the shadow-cursor profile for browser-based sharing when the cursor is missing.

Profiles live in resources/profiles/ and can be selected from the app settings. If you see a double cursor on macOS, switch back to the default profile.

All detailed documentation is under the docs/ directory:

• User Guide: docs/user-guide/
• Developer Guide: docs/developer/
• Technical Docs: docs/technical/
• Profiles & Platform Settings: docs/profiles/
• Changelog: docs/changelog/
• Archive: docs/archive/

Each section contains platform-specific details and comparison tables where relevant.

For details, see docs/technical/ and docs/user-guide/.

Past experiments, failed approaches, and technical lessons are preserved in docs/archive/. See archive README for details.

See CONTRIBUTING.md and docs/developer/ for guidelines.

• Region Selection: Pixel-perfect control via draggable/resizable border
• Multi-Monitor: Auto-detects when you drag border to different display
• Live Adjustment: Move/resize region while capturing (no restart needed)
• Multiple Capture Methods:
  • Windows: GPU (WGC) or CPU (GDI) fallback
  • macOS: ScreenCaptureKit (GPU) or CoreGraphics (CPU)
  • Linux: PipeWire (Wayland) or X11

• Cursor Control: Show/hide your cursor in capture
• Click Highlights: Visual feedback with customizable colors and dissolve effects
• Recording Indicator: "REC" badge shows when capturing is active

• Modes: Capture All, Exclude (hide selected windows/apps), Include Only (capture only selected)
• Manual Refresh: Load running apps/windows on demand; no auto-polling
• Search & View: Filter by text; switch between application or window list views
• Selection UX: Multi-select and add/remove; current picks visible at the top; clear-all control
• Preview Safety: Auto-exclude preview window toggle to avoid mirror loops
• Platform Coverage: macOS (CG + NSWorkspace) and Windows (EnumWindows, visible/non-cloaked, non-tool windows); Linux planned

• Border Styling: Adjustable width, color, and visibility
• Performance Tuning: FPS control (15-144 FPS), GPU acceleration toggle
• Capture Profiles: Pre-configured settings for different apps (Discord, Meet, etc.)
• Remember Region: Automatically restore last capture area

→ See Platform-Specific Documentation for technical details

RustFrame uses a modular, cross-platform architecture:

UI Layer (Tauri + React)
    ↓
Application Core (Rust)
    ↓
Platform Abstractions (Traits)
    ↓
Platform-Specific Implementations

• Capture Engines - Platform-specific screen capture (WGC, SCK, X11)
• Window Management - Hollow border and preview windows
• Rendering Pipeline - GPU or CPU rendering based on platform
• Settings Management - Persistent configuration with JSON

→ See Architecture Overview for details

• Rust (latest stable)
• Node.js (v18+) for UI
• Platform Tools:
  • Windows: Visual Studio Build Tools (MSVC)
  • macOS: Xcode Command Line Tools
  • Linux: GCC, GTK3, WebKit2GTK

# Clone repository
git clone https://github.com/salihcantekin/RustFrame
cd RustFrame

# Development mode
cargo tauri dev

# Release build
cargo tauri build

→ See Building Guide for detailed instructions

We welcome contributions! Here's how to get started:

1. Read the Guides

   • CONTRIBUTING.md - Contribution guidelines
   • CODE_OF_CONDUCT.md - Community standards
   • Developer Guide - Technical documentation

2. Find an Issue

   • Check GitHub Issues
   • Look for good-first-issue label

3. Submit a PR

   • Fork the repository
   • Create a feature branch
   • Make your changes
   • Submit a pull request

• macOS: Click highlights use CPU instead of GPU (optimization planned)
• Linux: PipeWire support experimental, may have compatibility issues

→ See Known Issues for complete list

• Zero-copy GPU texture sharing (eliminate CPU copy)
• Global hotkeys for start/stop
• Region presets (save/load favorite regions)

• Complete Documentation Index - All documentation
• GPU Optimization Details - Platform GPU strategies
• Multi-Monitor Implementation - Display detection
• Color Format Handling - BGRA vs RGBA

• Windows Graphics Capture API
• macOS ScreenCaptureKit
• Tauri Framework

MIT License - see LICENSE for details

• Repository: https://github.com/salihcantekin/RustFrame
• Releases: https://github.com/salihcantekin/RustFrame/releases
• Issues: https://github.com/salihcantekin/RustFrame/issues
• Discussions: https://github.com/salihcantekin/RustFrame/discussions
• Changelog: docs/changelog/README.md
• Security: SECURITY.md

Made with ❤️ using Rust + Tauri + React

Star ⭐ this repo if RustFrame helps you!

• COM Programming: Creating and managing COM objects in Rust
• Windows.Graphics.Capture: Modern screen capture API
• Direct3D 11: GPU device creation, texture management
• DXGI: DirectX Graphics Infrastructure and swapchains
• WinRT Interop: Bridging Win32 and WinRT APIs

• Unsafe Code: Proper use of unsafe with justification
• FFI: Calling Windows APIs through windows crate
• Resource Management: RAII, Drop implementations
• Thread Safety: Arc, Mutex, Send/Sync

• GPU Rendering: wgpu render pipelines
• Shader Programming: WGSL shaders
• Texture Management: Staging, mapping, uploading
• Swapchain Presentation: Frame synchronization

• Microsoft: Windows.Graphics.Capture API documentation
• wgpu Community: Excellent graphics API and examples
• windows-rs: Official Rust bindings for Windows

MIT License - See LICENSE file for details.

Developed by Salih Cantekin

Built with ❤️ and Rust 🦀 for the Windows platform