Installation

IronRDP is published to crates.io and can be added to your Rust project using Cargo.

Prerequisites

Before installing IronRDP, ensure you have:

Rust toolchain: Version 1.88.0 or later (as specified in rust-toolchain.toml)
Cargo: Rust’s package manager (included with Rust)

IronRDP uses Rust Edition 2021 and requires a modern Rust toolchain.

Basic Installation

Add IronRDP to your Cargo.toml:

[dependencies]
ironrdp = "0.14"

By default, this enables the core and pdu features, providing basic types and PDU encoding/decoding.

Feature-Based Installation

IronRDP is designed as a meta crate with optional feature flags. Choose the features you need:

Client Development

For building RDP clients:

[dependencies]
ironrdp = { version = "0.14", features = ["connector", "session", "graphics"] }

Required features:

connector - Client connection state machines (ironrdp-connector)
session - Session state machines (ironrdp-session)
graphics - Image processing primitives (ironrdp-graphics)

Server Development

For building RDP servers:

[dependencies]
ironrdp = { version = "0.14", features = ["acceptor", "server"] }

Required features:

acceptor - Server connection acceptance (ironrdp-acceptor)
server - Server implementation skeleton (ironrdp-server)

Virtual Channels

Add support for specific virtual channels:

[dependencies]
ironrdp = { version = "0.14", features = [
    "cliprdr",        # Clipboard redirection
    "rdpdr",          # Device redirection
    "rdpsnd",         # Audio output
    "displaycontrol", # Display control
    "svc",            # Static virtual channels base
    "dvc",            # Dynamic virtual channels
] }

Complete Feature Reference

Core Features

core - Common traits and types (ironrdp-core) [default]
pdu - PDU encoding and decoding (ironrdp-pdu) [default]

Connection & Session

connector - Client connection state machines (ironrdp-connector)
acceptor - Server connection acceptance (ironrdp-acceptor)
session - Session state machines (ironrdp-session)

Media & Graphics

graphics - Image processing primitives (ironrdp-graphics)
input - Input packet utilities (ironrdp-input)
qoi - QOI codec support
qoiz - QOIZ codec support

Virtual Channels

svc - Static virtual channel traits (ironrdp-svc)
dvc - Dynamic virtual channel implementation (ironrdp-dvc)
cliprdr - Clipboard redirection (ironrdp-cliprdr)
rdpdr - Device redirection (ironrdp-rdpdr)
rdpsnd - Audio output (ironrdp-rdpsnd)
displaycontrol - Display control channel (ironrdp-displaycontrol)
echo - Echo channel (ironrdp-echo)

Server

server - Server implementation skeleton (ironrdp-server)

I/O Layer Installation

IronRDP’s core is I/O-agnostic. Choose an I/O layer based on your needs:

Blocking I/O

For synchronous applications:

[dependencies]
ironrdp = { version = "0.14", features = ["connector", "session"] }
ironrdp-blocking = "0.8"

Use case: Simple clients, CLI tools, examples

Async I/O with Tokio

For async applications using Tokio:

[dependencies]
ironrdp = { version = "0.14", features = ["connector", "session"] }
ironrdp-tokio = "0.5"
tokio = { version = "1", features = ["full"] }

Use case: High-performance servers, concurrent clients

Async I/O with Futures

For async applications using the Futures crate:

[dependencies]
ironrdp = { version = "0.14", features = ["connector", "session"] }
ironrdp-async = "0.8"
ironrdp-futures = "0.5"

Use case: Custom async runtimes, async-std users

Additional Dependencies

Depending on your use case, you may need:

For TLS Support

[dependencies]
ironrdp-tls = "0.5"
tokio-rustls = "0.26"

For CredSSP Authentication

[dependencies]
sspi = { version = "0.18", features = ["network_client"] }

For Native Clipboard Support

[dependencies]
ironrdp-cliprdr-native = "0.5"

For Image Processing (Examples)

[dependencies]
image = { version = "0.25", default-features = false, features = ["png"] }

Platform-Specific Considerations

No Standard Library (`no_std`)

All core-tier crates are no_std-compatible:

[dependencies]
ironrdp-core = { version = "0.1", default-features = false }
ironrdp-pdu = { version = "0.7", default-features = false }

Enable the std feature flag if you need standard library support:

ironrdp-pdu = { version = "0.7", default-features = false, features = ["std"] }

WebAssembly (WASM)

For browser-based RDP clients:

[dependencies]
ironrdp-web = "0.8"

Build target:

rustup target add wasm32-unknown-unknown
cargo build --target wasm32-unknown-unknown

Verification

Verify your installation by building a minimal example:

use ironrdp::pdu::gcc::KeyboardType;
use ironrdp::connector::{Config, Credentials, DesktopSize};

fn main() {
    let config = Config {
        credentials: Credentials::UsernamePassword {
            username: String::from("user"),
            password: String::from("pass"),
        },
        domain: None,
        enable_tls: true,
        enable_credssp: true,
        keyboard_type: KeyboardType::IbmEnhanced,
        desktop_size: DesktopSize {
            width: 1280,
            height: 1024,
        },
        // ... other required fields with defaults
        ..Default::default()
    };

    println!("IronRDP config created: {}x{}", 
             config.desktop_size.width, 
             config.desktop_size.height);
}

The Config struct has many required fields. The examples above are simplified. See the Quickstart for complete configuration examples.

Running Examples

The IronRDP repository includes runnable examples:

Screenshot Example (Client)

git clone https://github.com/Devolutions/IronRDP.git
cd IronRDP
cargo run --example=screenshot -- --host <HOSTNAME> -u <USERNAME> -p <PASSWORD> -o out.png

Server Example

cargo run --example=server -- --bind-addr 127.0.0.1:3389 --user user --pass pass

Full Client (ironrdp-client)

cargo run --bin ironrdp-client -- <HOSTNAME> --username <USERNAME> --password <PASSWORD>

Type Definitions

Key types you’ll interact with after installation:

Connection Types

// From ironrdp::connector
pub struct Config { /* ... */ }
pub enum Credentials {
    UsernamePassword { username: String, password: String },
    SmartCard { /* ... */ },
}
pub struct DesktopSize {
    pub width: u16,
    pub height: u16,
}
pub struct ConnectionResult { /* ... */ }

Session Types

// From ironrdp::session
pub struct ActiveStage { /* ... */ }
pub enum ActiveStageOutput {
    ResponseFrame(Vec<u8>),
    GraphicsUpdate(/* ... */),
    Terminate(/* ... */),
}

PDU Types

// From ironrdp::pdu
use ironrdp_pdu::rdp::client_info::CompressionType;
use ironrdp_pdu::rdp::capability_sets::MajorPlatformType;

Troubleshooting

Compilation Errors

Missing feature flags

Error: cannot find type X in module YSolution: Enable the required feature flag:

ironrdp = { version = "0.14", features = ["session"] }

Version conflicts

Error: failed to select a version for ironrdp-*Solution: Use compatible versions across all IronRDP crates. The meta crate handles this automatically.

Minimum Rust version

Error: Compilation fails with older Rust versionsSolution: Update Rust to 1.88.0 or later:

rustup update stable

Get Started

Architecture

Core Concepts

Guides

Prerequisites

Basic Installation

Feature-Based Installation

Client Development

Server Development

Virtual Channels

Complete Feature Reference

I/O Layer Installation

Blocking I/O

Async I/O with Tokio

Async I/O with Futures

Additional Dependencies

For TLS Support

For CredSSP Authentication

For Native Clipboard Support

For Image Processing (Examples)

Platform-Specific Considerations

No Standard Library (`no_std`)

WebAssembly (WASM)

Verification

Running Examples

Screenshot Example (Client)

Server Example

Full Client (ironrdp-client)

Type Definitions

Connection Types

Session Types

PDU Types

Troubleshooting

Compilation Errors

Next Steps

Quickstart

API Reference

​Prerequisites

​Basic Installation

​Feature-Based Installation

​Client Development

​Server Development

​Virtual Channels

​Complete Feature Reference

​I/O Layer Installation

​Blocking I/O

​Async I/O with Tokio

​Async I/O with Futures

​Additional Dependencies

​For TLS Support

​For CredSSP Authentication

​For Native Clipboard Support

​For Image Processing (Examples)

​Platform-Specific Considerations

​No Standard Library (no_std)

​WebAssembly (WASM)

​Verification

​Running Examples

​Screenshot Example (Client)

​Server Example

​Full Client (ironrdp-client)

​Type Definitions

​Connection Types

​Session Types

​PDU Types

​Troubleshooting

​Compilation Errors

​Next Steps

Quickstart

API Reference

Prerequisites

Basic Installation

Feature-Based Installation

Client Development

Server Development

Virtual Channels

Complete Feature Reference

I/O Layer Installation

Blocking I/O

Async I/O with Tokio

Async I/O with Futures

Additional Dependencies

For TLS Support

For CredSSP Authentication

For Native Clipboard Support

For Image Processing (Examples)

Platform-Specific Considerations

No Standard Library (`no_std`)

WebAssembly (WASM)

Verification

Running Examples

Screenshot Example (Client)

Server Example

Full Client (ironrdp-client)

Type Definitions

Connection Types

Session Types

PDU Types

Troubleshooting

Compilation Errors

Next Steps