Rust Quick Start

The Rust SDK is the canonical NNRP implementation. The Preview4 release exposes a transport-neutral runtime, independent transport provider crates, runtime-control frames, object/cache metadata, FFI artifacts for native SDKs, and browser WASM primitives.

Install

For a native TCP client/server:

cargo add nnrp-core@1.0.0-preview.4.17 nnrp-runtime@1.0.0-preview.4.17 nnrp-transport-tcp@1.0.0-preview.4.17
cargo add tokio --features macros,rt-multi-thread,net,io-util

Add only the transport packages your application uses:

cargo add nnrp-transport-quic@1.0.0-preview.4.17
cargo add nnrp-transport-ipc@1.0.0-preview.4.17
cargo add nnrp-transport-websocket@1.0.0-preview.4.17

FFI and browser primitives are separate boundaries:

cargo add nnrp-ffi@1.0.0-preview.4.17
cargo add nnrp-wasm@1.0.0-preview.4.17

Client

use std::sync::Arc;
use nnrp_core::{FrameSubmitMetadata, TransportId, TransportPolicy};
use nnrp_runtime::{
    ClientProviderRoutes, NnrpClient, NnrpClientConfig, NnrpClientOptions, NnrpTerminalEvent,
};
use nnrp_transport_tcp::TcpProvider;

let client = NnrpClient::connect(
    NnrpClientOptions {
        endpoint: "nnrp://127.0.0.1:4433/session/default".parse()?,
        provider_routes: ClientProviderRoutes::new(),
        transport_policy: TransportPolicy::Auto,
        session: NnrpClientConfig::default(),
    },
    [Arc::new(TcpProvider::default())],
).await?;
let mut session = client.open_session().await?;

let operation_id = 1;
let frame_id = session
    .submit_encoded(
        FrameSubmitMetadata {
            operation_id,
            ..FrameSubmitMetadata::default()
        },
        b"hello".to_vec(),
    )
    .await?;

let result = session.await_result().await?;
assert_eq!(result.operation_id, operation_id);
match result.event {
    NnrpTerminalEvent::Runtime(event) => assert_eq!(event.header.frame_id, frame_id),
    NnrpTerminalEvent::Lifecycle(event) => {
        eprintln!("operation {} ended locally as {:?}", event.operation_id, event.state)
    }
};
session.close().await?;

Use await_event instead of await_result when the server can send progress, partial results, backpressure, object/cache events, or result-drop reasons.

Server

use std::sync::Arc;
use nnrp_core::{ResultPushMetadata, TransportPolicy};
use nnrp_runtime::{NnrpServer, NnrpServerConfig, NnrpServerOptions, ServerProviderRoutes};
use nnrp_transport_tcp::TcpProvider;

let server = NnrpServer::listen(
    NnrpServerOptions {
        endpoint: "nnrp://127.0.0.1:4433/session/default".parse()?,
        provider_routes: ServerProviderRoutes::new(),
        transport_policy: TransportPolicy::Auto,
        session: NnrpServerConfig::default(),
    },
    [Arc::new(TcpProvider::default())],
).await?;

let mut session = server.accept().await?;
let operation = session.receive_submit().await?;

operation
    .send_result(
        &mut session,
        ResultPushMetadata::default(),
        operation.body().to_vec(),
    )
    .await?;
session.close().await?;

Transport Packages

Each transport package owns real transport behavior. Installing a package is not just a feature flag.

Package	Use when	Runtime shape
nnrp-transport-tcp	Plain native TCP is enough	Connects/binds TCP framed transports
nnrp-transport-quic	You need QUIC streams, TLS, or better migration behavior	Connects/binds Quinn/Rustls transports
nnrp-transport-ipc	Client and server live on the same node	Uses Unix domain sockets or Windows named pipes
nnrp-transport-websocket	You need binary NNRP frames over WebSocket	Provides native Rust WebSocket transport

Provider selection and probing are described in Rust API Overview.

Next Pages

1. Client API for session submission, control, object/cache events, and close semantics.
2. Server API for accept loops, result/progress sending, control receive, and runtime feedback.
3. Core Types for profiles, message types, metadata, and registries.
4. FFI / Native and WASM for downstream SDK packaging boundaries.