# Iroh Development Roadmap: QUIC Transport, Scalable Relays, and Production APIs

> Explore the iroh development roadmap: discover plans for QUIC transport, scalable relays, and production APIs. See active development progress in the n0-computer/iroh repository.

- Repository: [number zero/iroh](https://github.com/n0-computer/iroh)
- Tags: development-roadmap
- Published: 2026-06-23

---

**The iroh development roadmap focuses on stabilizing QUIC transport, scaling relay infrastructure, and shipping production-ready client APIs, with active development tracked in the n0-computer/iroh repository's source code and CI configuration.**

Iroh is a modular Rust implementation providing a peer-to-peer data exchange layer, relay service, and DNS resolver. While the project does not publish a standalone [`ROADMAP.md`](https://github.com/n0-computer/iroh/blob/main/ROADMAP.md), the development direction is clearly encoded in the crate architecture, feature flags, and test suites. This roadmap emerges from the ongoing work in `iroh-base`, `iroh-relay`, and `iroh-dns`, revealing a trajectory toward production-grade networking.

## Current Architecture and Foundation

The iroh codebase is organized into three core crates that define the current capabilities and future extension points.

### Core Crate Structure

- **iroh-base** – Provides shared primitives including **relay URLs**, cryptographic keys, and endpoint addresses. The `RelayUrl` type defined in [`iroh-base/src/relay_url.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-base/src/relay_url.rs) serves as the fundamental identifier for relay nodes.
- **iroh-relay** – Implements the relay server with HTTP and TLS support in [`iroh-relay/src/server.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/server.rs), and houses the experimental QUIC transport implementation in [`iroh-relay/src/quic.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/quic.rs).
- **iroh-dns** – Contains a DNS-over-HTTPS resolver in [`iroh-dns/src/dns.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-dns/src/dns.rs) used by the relay system for endpoint discovery.

## Key Milestones on the Iroh Roadmap

The following priorities are observable in the source tree and represent the maintainers' strategic focus.

### 1. Stabilizing QUIC as the Primary Transport

The development team is actively refining QUIC support to make it the default transport protocol. In [`iroh-relay/src/quic.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/quic.rs), the QUIC module is compiled behind the `quic` feature flag, indicating ongoing stabilization work. Future releases will complete the QUIC handshake logic, optimize performance, and transition the relay from HTTP to QUIC-first connectivity.

### 2. Relay Scalability and Multi-Host Support

Production scalability is a near-term priority evidenced by test infrastructure like [`iroh-relay/tests/multiple-hostnames-pebble.sh`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/tests/multiple-hostnames-pebble.sh). This test harness validates TLS certificate handling across multiple hostnames. The roadmap includes automatic certificate provisioning, load balancing across relay nodes, and a management API for operators running large-scale relay fleets.

### 3. Production-Ready DNS Resolution

The `iroh-dns` crate currently provides a minimal DNS-over-HTTPS client. Planned enhancements include DNS response caching, DNSSEC validation, and resolver failover mechanisms to make the DNS subsystem production-ready for high-throughput environments.

### 4. Ergonomic High-Level Client APIs

While the repository currently exposes low-level primitives, the next milestone targets a stable, ergonomic client API. The `ClientBuilder` pattern (referenced in [`iroh-relay/src/client.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/client.rs)) will hide protocol complexity behind simple configuration methods, enabling developers to establish peer-to-peer connections without managing transport details manually.

### 5. Cross-Platform Packaging and Distribution

Containerization and binary distribution are active workstreams. The `docker/Dockerfile` and `docker/Dockerfile.ci` files, along with [`.github/workflows/docker.yaml`](https://github.com/n0-computer/iroh/blob/main/.github/workflows/docker.yaml), demonstrate the project's progress toward shipping pre-built relay containers, Windows binaries, and Homebrew taps for seamless deployment.

### 6. Feature Parity with Content-Addressed Protocols

The repository mirrors the original iroh protocol specifications. Future milestones aim to achieve feature parity with content addressing and chunked transfer capabilities, ensuring the Rust implementation can support distributed file synchronization and remote backup workloads while maintaining the codebase's pure Rust constraints.

## Implementation Preview: Connecting to a QUIC-Enabled Relay

The following example demonstrates how client code interacts with the current API, using the `quic` feature to future-proof against the upcoming transport changes.

```rust
use iroh_base::{RelayUrl, EndpointAddr};
use iroh_relay::client::{Client, ClientBuilder};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Construct the relay URL (replace with your own relay address)
    let relay = RelayUrl::from_str("https://relay.example.com")?;

    // Build a client that prefers QUIC (the `quic` feature is enabled)
    let client: Client = ClientBuilder::new()
        .relay(relay)
        .prefer_quic(true)      // future-default once QUIC stabilises
        .build()
        .await?;

    // Resolve an endpoint address through the relay's DNS service
    let endpoint: EndpointAddr = client.resolve("example.iroh").await?;

    println!("Resolved endpoint: {}", endpoint);
    Ok(())
}

```

Key implementation details illustrated above include `RelayUrl` from [`iroh-base/src/relay_url.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-base/src/relay_url.rs), the `ClientBuilder` API in [`iroh-relay/src/client.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/client.rs), and DNS resolution delegated to the relay subsystem.

## Tracking Progress in the Source Code

Specific files provide evidence of roadmap progress:

- **[`iroh-relay/src/quic.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/quic.rs)** – Active QUIC transport development
- **[`iroh-relay/tests/multiple-hostnames-pebble.sh`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/tests/multiple-hostnames-pebble.sh)** – Multi-hostname TLS testing
- **[`iroh-dns/src/dns.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-dns/src/dns.rs)** – DNS-over-HTTPS resolver evolution
- **[`DEVELOPMENT.md`](https://github.com/n0-computer/iroh/blob/main/DEVELOPMENT.md)** – Documentation build processes and contribution guidelines
- **[`CHANGELOG.md`](https://github.com/n0-computer/iroh/blob/main/CHANGELOG.md)** – Release history showing progression toward QUIC and DNS features
- **`docker/Dockerfile`** – Containerization strategy for production deployments

## Summary

- **QUIC transport** is being stabilized in [`iroh-relay/src/quic.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/quic.rs) and will become the default protocol.
- **Relay scalability** work focuses on multi-hostname support and automated certificate management via test suites like [`multiple-hostnames-pebble.sh`](https://github.com/n0-computer/iroh/blob/main/multiple-hostnames-pebble.sh).
- **DNS improvements** aim to add caching and DNSSEC validation to the `iroh-dns` crate.
- **Client APIs** are evolving toward ergonomic builders that abstract transport complexity.
- **Packaging** efforts include Docker containers, Windows binaries, and Homebrew distribution.
- **Protocol parity** with content-addressed features remains a long-term goal for distributed storage applications.

## Frequently Asked Questions

### Is there an official ROADMAP.md file for iroh?

No, the n0-computer/iroh repository does not contain a dedicated [`ROADMAP.md`](https://github.com/n0-computer/iroh/blob/main/ROADMAP.md). Instead, the development roadmap is inferred from the source code structure, feature flags in [`Cargo.toml`](https://github.com/n0-computer/iroh/blob/main/Cargo.toml), active test suites, and CI configuration files that reveal the maintainers' priorities.

### When will QUIC become the default transport in iroh?

QUIC support is currently gated behind the `quic` feature flag in [`iroh-relay/src/quic.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/quic.rs). The transition to default status depends on completing handshake refinements and performance optimizations. Monitor the [`CHANGELOG.md`](https://github.com/n0-computer/iroh/blob/main/CHANGELOG.md) and QUIC-related PRs for stabilization announcements.

### How can I contribute to the iroh relay scalability efforts?

Contributors can examine the test infrastructure in [`iroh-relay/tests/multiple-hostnames-pebble.sh`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/tests/multiple-hostnames-pebble.sh) and the server implementation in [`iroh-relay/src/server.rs`](https://github.com/n0-computer/iroh/blob/main/iroh-relay/src/server.rs). Focus areas include TLS certificate automation, load balancing logic, and the management API for multi-node relay clusters.

### What platforms will iroh support for production deployments?

The presence of `docker/Dockerfile` and Windows-specific CI workflows indicates support for Linux containers and Windows binaries. The roadmap also includes Homebrew distribution for macOS, making the relay and client libraries available across major operating systems.