Crate rustvncserver 

rustvncserver

A pure Rust implementation of a VNC (Virtual Network Computing) server.

This library provides a complete VNC server implementation following the RFB (Remote Framebuffer) protocol specification (RFC 6143). It supports all major VNC encodings and pixel formats, with 100% wire-format compatibility with standard VNC protocol.

Features

• 11 encoding types: Raw, CopyRect, RRE, CoRRE, Hextile, Zlib, ZlibHex, Tight, TightPng, ZRLE, ZYWRLE
• All pixel formats: 8/16/24/32-bit color depths
• Tight encoding: All 5 production modes (solid fill, mono rect, indexed palette, full-color zlib, JPEG)
• Async I/O: Built on Tokio for efficient concurrent client handling
• Memory safe: Pure Rust with zero unsafe code in core logic
• Optional TurboJPEG: Hardware-accelerated JPEG compression via feature flag

Quick Start

use rustvncserver::VncServer;
use rustvncserver::server::ServerEvent;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a VNC server with 1920x1080 framebuffer
    let (server, mut event_rx) = VncServer::new(
        1920,
        1080,
        "My Desktop".to_string(),
        Some("secret".to_string()), // Optional password
    );

    // Handle events from clients in a background task
    tokio::spawn(async move {
        while let Some(event) = event_rx.recv().await {
            match event {
                ServerEvent::ClientConnected { client_id } => {
                    println!("Client {} connected", client_id);
                }
                ServerEvent::ClientDisconnected { client_id } => {
                    println!("Client {} disconnected", client_id);
                }
                _ => {}
            }
        }
    });

    // Start listening on port 5900 (blocks until server stops)
    server.listen(5900).await?;
    Ok(())
}

Architecture

┌─────────────────────────────────────────┐
│           Your Application              │
│                                         │
│  • Provide framebuffer data             │
│  • Receive input events                 │
│  • Control server lifecycle             │
└──────────────────┬──────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────┐
│           VncServer (Public)            │
│                                         │
│  • TCP listener                         │
│  • Client management                    │
│  • Event distribution                   │
└──────────────────┬──────────────────────┘
                   │
       ┌───────────┼───────────┐
       ▼           ▼           ▼
  ┌────────┐ ┌────────┐ ┌────────┐
  │Client 1│ │Client 2│ │Client N│
  └────────┘ └────────┘ └────────┘
       │           │           │
       └───────────┴───────────┘
                   │
                   ▼
┌─────────────────────────────────────────┐
│      Framebuffer (Thread-safe)          │
│                                         │
│  • RGBA32 pixel storage                 │
│  • Region tracking                      │
│  • CopyRect operations                  │
└─────────────────────────────────────────┘

Re-exports

pub use error::Result;

pub use error::VncError;

pub use events::ServerEvent;

pub use framebuffer::Framebuffer;

pub use server::VncServer;

pub use rfb_encodings as encoding;

Modules

error

Error types for the VNC server library.

events

Server events that can be received by the application.

framebuffer

VNC framebuffer management and dirty region tracking.

protocol

VNC Remote Framebuffer (RFB) protocol constants and structures.

server

VNC server implementation for managing client connections and framebuffer distribution.

Structs

PixelFormat

Represents the pixel format used in RFB protocol.

TurboJpegEncoder

Safe Rust wrapper for TurboJPEG compression.

Constants

DEFAULT_PORT

Default VNC port.

PROTOCOL_VERSION

VNC protocol version.

Traits

Encoding

Trait defining the interface for RFB encoding implementations.