Roadmap for Iroh: QUIC Transport, Scalable Relays, and Production APIs

The roadmap for iroh focuses on stabilizing QUIC as the default transport, scaling relay infrastructure with automatic certificate management, and shipping production-ready DNS resolution and ergonomic client APIs, with all priorities encoded directly in the n0-computer/iroh source tree.

The iroh project is a modular Rust implementation that provides a peer-to-peer data exchange layer, relay service, and DNS resolver. While the repository does not maintain a standalone ROADMAP.md, the development direction is explicitly mapped through feature flags, test suites, and architectural patterns in the codebase. This guide extracts the seven strategic priorities currently driving the project forward.

Current Architecture

The foundation of the roadmap rests on three core crates that define the current stack:

• iroh-base: Shared primitives including RelayUrl and endpoint addresses (src/relay_url.rs)
• iroh-relay: Relay server implementation with HTTP and QUIC support (src/server.rs, src/quic.rs)
• iroh-dns: DNS-over-HTTPS resolver used by the relay subsystem (src/dns.rs)

Development Priorities on the Roadmap for Iroh

1. Stabilizing and Expanding QUIC Transport

The most significant infrastructure change in the roadmap for iroh is the migration toward QUIC as the default transport. The presence of iroh-relay/src/quic.rs, compiled behind the quic feature flag, indicates active development on the QUIC handshake and performance optimization. Future milestones include completing the QUIC implementation to make it the preferred protocol for relay connections, reducing latency compared to the current HTTP-based transport.

2. Relay Scalability and Multi-Host Handling

Production deployments require robust multi-node support. The test script iroh-relay/tests/multiple-hostnames-pebble.sh reveals ongoing work for handling multiple hostnames and TLS certificate provisioning. The roadmap includes automatic certificate management, load-balancing across relay nodes, and a management API for operators running infrastructure at scale.

3. Production-Ready DNS Resolution

The iroh-dns crate currently provides a minimal DNS-over-HTTPS client in src/dns.rs. Upcoming development focuses on adding caching layers, DNSSEC validation, and richer resolver features to make the DNS subsystem production-ready for high-throughput environments.

4. Higher-Level Client APIs

While the current crates expose low-level primitives, the next major milestone targets stable, ergonomic client libraries. The pattern established in iroh::client::Builder (located in iroh-relay/src/client.rs) will evolve into a public API that hides protocol complexity, allowing developers to establish peer-to-peer connections without managing underlying relay or QUIC details directly.

5. Documentation and End-to-End Examples

The DEVELOPMENT.md and README.md files already specify documentation builds using --all-features. The roadmap expands this to include comprehensive end-to-end examples demonstrating file synchronization, remote backup workflows, and CI-driven documentation publishing to support the growing developer ecosystem.

6. Cross-Platform Packaging and Distribution

Infrastructure automation in .github/workflows/docker.yaml and docker/Dockerfile signals the push toward production distribution. The roadmap includes pre-built relay containers, Windows binary releases, and a Homebrew tap to simplify deployment across development and production environments.

7. Feature Parity with Content Addressing

As a Rust reimplementation of the original iroh protocol, the repository aims to achieve full feature parity. This includes implementing content addressing, chunked transfer protocols, and advanced data synchronization primitives while maintaining the codebase's pure Rust architecture.

Preparing for the QUIC-First Future

Developers can future-proof applications today by enabling the quic feature and using the ClientBuilder API. The following example demonstrates connecting to a relay with QUIC preference enabled:

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

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

    // Build a client that prefers QUIC transport
    let client: Client = ClientBuilder::new()
        .relay(relay)
        .prefer_quic(true)  // Future default once QUIC stabilizes
        .build()
        .await?;

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

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

Key components referenced include RelayUrl from iroh-base/src/relay_url.rs, the ClientBuilder pattern in iroh-relay/src/client.rs, and DNS resolution via iroh-dns/src/dns.rs.

Summary

The roadmap for iroh is actively encoded in the source code of n0-computer/iroh through:

• QUIC transport development in iroh-relay/src/quic.rs behind the quic feature
• Multi-host scalability testing in iroh-relay/tests/multiple-hostnames-pebble.sh
• DNS enhancements planned for iroh-dns/src/dns.rs including caching and DNSSEC
• Higher-level APIs evolving from the current ClientBuilder patterns in iroh-relay/src/client.rs
• Production packaging via Docker workflows and CI automation
• Documentation expansion targeting end-to-end examples and cross-platform distribution

Frequently Asked Questions

Does iroh publish an official roadmap document?

No, the repository does not contain a dedicated ROADMAP.md. Instead, the development direction is communicated implicitly through the evolution of the codebase, feature flags, test suites, and CI configuration files. By examining patterns in iroh-relay/src/quic.rs and infrastructure tests like multiple-hostnames-pebble.sh, contributors can infer the current priorities.

When will QUIC become the default transport in iroh?

QUIC support is currently available behind the quic feature flag in iroh-relay/src/quic.rs. The roadmap targets stabilizing the QUIC handshake and performance characteristics before making it the default. Developers can prepare by enabling .prefer_quic(true) in ClientBuilder configurations today.

How can I contribute to the iroh roadmap priorities?

Contributors should examine the test infrastructure in iroh-relay/tests/, the DNS implementation in iroh-dns/src/dns.rs, and the CI workflows in .github/workflows/ to identify active development areas. Pull requests addressing QUIC stability, DNS caching, or documentation examples align directly with the inferred roadmap.

What platforms will iroh support for production relays?

The presence of docker/Dockerfile and .github/workflows/docker.yaml indicates immediate support for containerized deployments. The roadmap extends to Windows binaries and Homebrew distribution based on the existing CI configuration and packaging scripts found in the repository root.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}