| Crates.io | xrpc-rs |
| lib.rs | xrpc-rs |
| version | 0.2.0 |
| created_at | 2025-11-23 13:21:56.242794+00 |
| updated_at | 2025-12-20 09:13:17.574835+00 |
| description | async RPC library optimized for shared memory communication |
| homepage | |
| repository | https://github.com/geminik23/xrpc-rs |
| max_upload_size | |
| id | 1946552 |
| size | 262,054 |
High-performance local IPC library for Rust with seamless transport flexibility.
Start with in-process channels for development, scale to shared memory for production IPC, extend to TCP for network deployment—same interface.
Status: Early prototype - working but not production-ready.
use xrpc::{
RpcClient, RpcServer, MessageChannelAdapter,
SharedMemoryFrameTransport, SharedMemoryConfig,
};
use serde::{Serialize, Deserialize};
use std::sync::Arc;
#[derive(Serialize, Deserialize)]
struct AddRequest { a: i32, b: i32 }
#[derive(Serialize, Deserialize)]
struct AddResponse { result: i32 }
// =================== Server
let transport = SharedMemoryFrameTransport::create_server("my_service", SharedMemoryConfig::default())?;
let channel = Arc::new(MessageChannelAdapter::new(transport));
let server = RpcServer::new();
server.register_typed("add", |req: AddRequest| async move {
Ok(AddResponse { result: req.a + req.b })
});
server.serve(channel).await?;
// =================== Client
let transport = SharedMemoryFrameTransport::connect_client("my_service")?;
let channel = MessageChannelAdapter::new(transport);
let client = RpcClient::new(channel);
let _handle = client.start();
let resp: AddResponse = client.call("add", &AddRequest { a: 1, b: 2 }).await?;
assert_eq!(resp.result, 3);
[dependencies]
xrpc-rs = "0.2"
# Optional codecs: codec-messagepack, codec-cbor, codec-postcard, codec-all
xrpc-rs = { version = "0.2", features = ["codec-messagepack"] }
| Feature | Status |
|---|---|
| FrameTransport Layer (TCP, Unix, SharedMemory, Channel) | Completed |
| MessageChannel with compression | Completed |
| RPC Client/Server | Completed |
| Streaming | Completed |
| Connection Pooling | Completed |
| Batching | Planned |
| Service Discovery & Load Balancing | Planned |
xRPC follows a layered architecture:
| Layer | Trait/Module | Description |
|---|---|---|
| Layer 1 | FrameTransport |
Low-level byte transmission with framing |
| Layer 2 | MessageChannel |
Message-aware channel with compression |
| Layer 3 | RpcClient/RpcServer |
RPC with method dispatch, streaming |
| Layer 4 | Advanced | Batching, service discovery, load balancing |
Application
↓
RpcClient/RpcServer (Layer 3)
↓
MessageChannel (Layer 2)
↓
FrameTransport (Layer 1)
↓
Network/IPC
| Transport | Use Case | Cross-Process | Serialization |
|---|---|---|---|
SharedMemoryFrameTransport |
Production IPC | Yes | Yes |
TcpFrameTransport |
Network / Remote | Yes | Yes |
UnixFrameTransport |
Local IPC (Unix) | Yes | Yes |
ChannelFrameTransport |
Same-process / Testing | No | Yes |
ArcFrameTransport |
Same-process fast path | No | No (zero-copy) |
# Terminal 1
cargo run --example rpc_client_server -- server
# Terminal 2
cargo run --example rpc_client_server -- client
# Terminal 1
cargo run --example message_transport_shm -- server
# Terminal 2
cargo run --example message_transport_shm -- client
cargo run --example byte_transports
MIT License - see LICENSE for details.