{"id":42472444,"url":"https://github.com/joaquinbejar/ironsbe","last_synced_at":"2026-02-03T16:00:48.029Z","repository":{"id":334958753,"uuid":"1143493279","full_name":"joaquinbejar/IronSBE","owner":"joaquinbejar","description":"IronSBE is a complete Rust implementation of the [Simple Binary Encoding (SBE)](https://www.fixtrading.org/standards/sbe/) protocol, designed for ultra-low-latency financial systems. It provides both server and client capabilities with a focus on performance, type safety, and ease of use.","archived":false,"fork":false,"pushed_at":"2026-01-28T09:04:32.000Z","size":445,"stargazers_count":5,"open_issues_count":0,"forks_count":1,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-01-30T00:59:47.800Z","etag":null,"topics":["binary-encoding","finance","fix","low-latency","sbe","trading"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/joaquinbejar.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-01-27T16:42:48.000Z","updated_at":"2026-01-28T14:35:58.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/joaquinbejar/IronSBE","commit_stats":null,"previous_names":["joaquinbejar/ironsbe"],"tags_count":2,"template":false,"template_full_name":null,"purl":"pkg:github/joaquinbejar/IronSBE","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/joaquinbejar%2FIronSBE","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/joaquinbejar%2FIronSBE/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/joaquinbejar%2FIronSBE/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/joaquinbejar%2FIronSBE/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/joaquinbejar","download_url":"https://codeload.github.com/joaquinbejar/IronSBE/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/joaquinbejar%2FIronSBE/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28912222,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-30T11:55:24.701Z","status":"ssl_error","status_checked_at":"2026-01-30T11:54:13.194Z","response_time":66,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["binary-encoding","finance","fix","low-latency","sbe","trading"],"created_at":"2026-01-28T10:05:05.962Z","updated_at":"2026-01-30T12:02:10.556Z","avatar_url":"https://github.com/joaquinbejar.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cp align=\"center\"\u003e\n  \u003cimg src=\"doc/assets/ironsbe-logo.png\" alt=\"IronSBE Logo\" width=\"200\"/\u003e\n\u003c/p\u003e\n\n\u003ch1 align=\"center\"\u003eIronSBE\u003c/h1\u003e\n\n\u003cp align=\"center\"\u003e\n  \u003cstrong\u003eHigh-Performance Simple Binary Encoding (SBE) Server/Client for Rust\u003c/strong\u003e\n\u003c/p\u003e\n\n\u003cp align=\"center\"\u003e\n  \u003ca href=\"https://crates.io/crates/ironsbe\"\u003e\u003cimg src=\"https://img.shields.io/crates/v/ironsbe.svg\" alt=\"Crates.io\"/\u003e\u003c/a\u003e\n  \u003ca href=\"https://docs.rs/ironsbe\"\u003e\u003cimg src=\"https://docs.rs/ironsbe/badge.svg\" alt=\"Documentation\"/\u003e\u003c/a\u003e\n  \u003ca href=\"https://github.com/joaquinbejar/IronSBE/actions\"\u003e\u003cimg src=\"https://github.com/joaquinbejar/IronSBE/workflows/Build/badge.svg\" alt=\"Build Status\"/\u003e\u003c/a\u003e\n  \u003ca href=\"https://codecov.io/gh/joaquinbejar/IronSBE\"\u003e\u003cimg src=\"https://codecov.io/gh/joaquinbejar/IronSBE/branch/main/graph/badge.svg\" alt=\"Coverage\"/\u003e\u003c/a\u003e\n  \u003ca href=\"https://github.com/joaquinbejar/IronSBE/blob/main/LICENSE\"\u003e\u003cimg src=\"https://img.shields.io/badge/license-MIT-blue.svg\" alt=\"License\"/\u003e\u003c/a\u003e\n\u003c/p\u003e\n\n\u003cp align=\"center\"\u003e\n  Zero-copy • Schema-driven codegen • Sub-microsecond latency • Millions of msg/sec\n\u003c/p\u003e\n\n---\n\n## Overview\n\nIronSBE is a complete Rust implementation of the [Simple Binary Encoding (SBE)](https://www.fixtrading.org/standards/sbe/) protocol, designed for ultra-low-latency financial systems. It provides both server and client capabilities with a focus on performance, type safety, and ease of use.\n\nSBE is the binary encoding standard used by major exchanges including CME, Eurex, LSE, NASDAQ, and Binance for market data feeds and order entry systems.\n\n### Key Features\n\n- **Zero-copy decoding** - Direct buffer access with compile-time offset calculation\n- **Schema-driven code generation** - Type-safe messages from XML specifications\n- **Sub-microsecond latency** - Cache-friendly memory layouts with aligned buffers\n- **Multi-transport support** - TCP, UDP unicast/multicast, shared memory IPC\n- **A/B feed arbitration** - First-arrival-wins deduplication for redundant feeds\n- **Market data patterns** - Order book management, gap detection, snapshot recovery\n- **100% safe Rust** - No unsafe code in core library\n- **Async/await support** - Built on Tokio for high-performance async I/O\n\n---\n\n## Performance\n\nBenchmarked on Apple M4 Max 64GB, macOS Tahoe 26.2:\n\n| Operation | Latency (p50) | Latency (p99) | Throughput |\n|-----------|---------------|---------------|------------|\n| Encode NewOrderSingle | 3 ns | 4 ns | 342.8M msg/sec |\n| Decode NewOrderSingle | 1 ns | 1 ns | 1262.6M msg/sec |\n| Encode MarketData (10 entries) | 6 ns | 8 ns | 165.5M msg/sec |\n| Decode MarketData (10 entries) | 0 ns | 1 ns | 2178.6M msg/sec |\n| SPSC channel send | 2 ns | 2 ns | 648.5M msg/sec |\n| MPSC channel send | 7 ns | 9 ns | 145.5M msg/sec |\n| TCP round-trip (localhost) | 16.8 μs | 23.7 μs | 60K msg/sec |\n\nRun your own benchmarks:\n```bash\ncargo run --example benchmark_report --release\n```\n\n---\n\n## Quick Start\n\n### Installation\n\nAdd IronSBE to your `Cargo.toml`:\n\n```toml\n[dependencies]\nironsbe = \"0.1\"\n\n[build-dependencies]\nironsbe-codegen = \"0.1\"\n```\n\n### Define Your Schema\n\nCreate an SBE schema file (`schemas/trading.xml`):\n\n```xml\n\u003c?xml version=\"1.0\" encoding=\"UTF-8\"?\u003e\n\u003csbe:messageSchema xmlns:sbe=\"http://fixprotocol.io/2016/sbe\"\n                   package=\"trading\"\n                   id=\"1\"\n                   version=\"1\"\n                   byteOrder=\"littleEndian\"\u003e\n    \u003ctypes\u003e\n        \u003ccomposite name=\"messageHeader\"\u003e\n            \u003ctype name=\"blockLength\" primitiveType=\"uint16\"/\u003e\n            \u003ctype name=\"templateId\" primitiveType=\"uint16\"/\u003e\n            \u003ctype name=\"schemaId\" primitiveType=\"uint16\"/\u003e\n            \u003ctype name=\"version\" primitiveType=\"uint16\"/\u003e\n        \u003c/composite\u003e\n        \n        \u003cenum name=\"Side\" encodingType=\"uint8\"\u003e\n            \u003cvalidValue name=\"Buy\"\u003e1\u003c/validValue\u003e\n            \u003cvalidValue name=\"Sell\"\u003e2\u003c/validValue\u003e\n        \u003c/enum\u003e\n        \n        \u003ctype name=\"Symbol\" primitiveType=\"char\" length=\"8\"/\u003e\n        \u003ctype name=\"ClOrdId\" primitiveType=\"char\" length=\"20\"/\u003e\n    \u003c/types\u003e\n    \n    \u003csbe:message name=\"NewOrderSingle\" id=\"1\" blockLength=\"48\"\u003e\n        \u003cfield name=\"clOrdId\" id=\"11\" type=\"ClOrdId\" offset=\"0\"/\u003e\n        \u003cfield name=\"symbol\" id=\"55\" type=\"Symbol\" offset=\"20\"/\u003e\n        \u003cfield name=\"side\" id=\"54\" type=\"Side\" offset=\"28\"/\u003e\n        \u003cfield name=\"price\" id=\"44\" type=\"int64\" offset=\"29\"/\u003e\n        \u003cfield name=\"quantity\" id=\"38\" type=\"uint64\" offset=\"37\"/\u003e\n    \u003c/sbe:message\u003e\n\u003c/sbe:messageSchema\u003e\n```\n\n### Generate Code\n\nAdd to your `build.rs`:\n\n```rust\nfn main() {\n    ironsbe_codegen::generate(\n        \"schemas/trading.xml\",\n        \u0026format!(\"{}/trading.rs\", std::env::var(\"OUT_DIR\").unwrap()),\n    ).expect(\"Failed to generate SBE codecs\");\n}\n```\n\n### Encode Messages\n\n```rust\nuse ironsbe::prelude::*;\n\n// Include generated code\nmod trading {\n    include!(concat!(env!(\"OUT_DIR\"), \"/trading.rs\"));\n}\n\nuse trading::{NewOrderSingleEncoder, Side};\n\nfn main() {\n    // Allocate buffer (stack or pool)\n    let mut buffer = [0u8; 256];\n    \n    // Create encoder (writes header automatically)\n    let mut encoder = NewOrderSingleEncoder::wrap(\u0026mut buffer, 0);\n    \n    // Set fields with builder pattern\n    encoder\n        .set_cl_ord_id(b\"ORDER-001           \")\n        .set_symbol(b\"AAPL    \")\n        .set_side(Side::Buy)\n        .set_price(15050)      // $150.50 as fixed-point\n        .set_quantity(100);\n    \n    // Get encoded length\n    let len = encoder.encoded_length();\n    \n    // Send buffer[..len] over network\n    println!(\"Encoded {} bytes\", len);\n}\n```\n\n### Decode Messages\n\n```rust\nuse ironsbe::prelude::*;\n\nmod trading {\n    include!(concat!(env!(\"OUT_DIR\"), \"/trading.rs\"));\n}\n\nuse trading::{NewOrderSingleDecoder, SCHEMA_VERSION};\n\nfn main() {\n    // Received from network\n    let buffer: \u0026[u8] = /* ... */;\n    \n    // Zero-copy decode (no allocation)\n    let decoder = NewOrderSingleDecoder::wrap(\n        buffer,\n        MessageHeader::ENCODED_LENGTH,\n        SCHEMA_VERSION,\n    );\n    \n    // Access fields directly from buffer\n    println!(\"ClOrdId: {:?}\", decoder.cl_ord_id());\n    println!(\"Symbol: {:?}\", decoder.symbol());\n    println!(\"Side: {:?}\", decoder.side());\n    println!(\"Price: {}\", decoder.price());\n    println!(\"Quantity: {}\", decoder.quantity());\n}\n```\n\n---\n\n## Architecture\n\n```mermaid\ngraph TB\n    subgraph Application[\"Application Layer\"]\n        Server[\"Server Engine\"]\n        Client[\"Client Engine\"]\n        MarketData[\"Market Data Handler\"]\n    end\n\n    subgraph Channel[\"Channel Layer\"]\n        SPSC[\"SPSC\u003cbr/\u003e~20 ns\"]\n        MPSC[\"MPSC\u003cbr/\u003e~100 ns\"]\n        Broadcast[\"Broadcast\u003cbr/\u003e1-to-N\"]\n    end\n\n    subgraph Transport[\"Transport Layer\"]\n        TCP[\"TCP\u003cbr/\u003eTokio\"]\n        UDP[\"UDP\u003cbr/\u003eUnicast\"]\n        Multicast[\"Multicast\u003cbr/\u003eA/B\"]\n        IPC[\"IPC\u003cbr/\u003eSHM\"]\n    end\n\n    subgraph Codec[\"Codec Layer\"]\n        Encoders[\"Generated Encoders / Decoders\u003cbr/\u003eZero-copy, compile-time offsets, type-safe\"]\n        Core[\"ironsbe-core\u003cbr/\u003eBuffer traits, headers, primitives\"]\n    end\n\n    Server --\u003e SPSC\n    Server --\u003e MPSC\n    Client --\u003e SPSC\n    Client --\u003e MPSC\n    MarketData --\u003e Broadcast\n\n    SPSC --\u003e TCP\n    SPSC --\u003e UDP\n    MPSC --\u003e TCP\n    MPSC --\u003e Multicast\n    Broadcast --\u003e Multicast\n    Broadcast --\u003e IPC\n\n    TCP --\u003e Encoders\n    UDP --\u003e Encoders\n    Multicast --\u003e Encoders\n    IPC --\u003e Encoders\n    Encoders --\u003e Core\n```\n\n---\n\n## Crate Structure\n\nIronSBE is organized as a Cargo workspace with 11 crates:\n\n| Crate | Description |\n|-------|-------------|\n| [`ironsbe`](ironsbe/) | Facade crate re-exporting public API |\n| [`ironsbe-core`](ironsbe-core/) | Buffer traits, message headers, primitive types, encoder/decoder traits |\n| [`ironsbe-schema`](ironsbe-schema/) | SBE XML schema parser and validation |\n| [`ironsbe-codegen`](ironsbe-codegen/) | Build-time Rust code generation from SBE schemas |\n| [`ironsbe-derive`](ironsbe-derive/) | Procedural macros (`#[derive(SbeMessage)]`) |\n| [`ironsbe-channel`](ironsbe-channel/) | Lock-free SPSC/MPSC/Broadcast channels |\n| [`ironsbe-transport`](ironsbe-transport/) | TCP, UDP unicast/multicast, shared memory IPC |\n| [`ironsbe-server`](ironsbe-server/) | Async server engine with session management |\n| [`ironsbe-client`](ironsbe-client/) | Async client with auto-reconnection |\n| [`ironsbe-marketdata`](ironsbe-marketdata/) | Order book, gap detection, A/B feed arbitration |\n| [`ironsbe-bench`](ironsbe-bench/) | Benchmarks using Criterion |\n\n### Dependency Graph\n\n```\nironsbe (facade)\n├── ironsbe-core\n├── ironsbe-schema\n├── ironsbe-codegen\n├── ironsbe-channel\n├── ironsbe-transport\n├── ironsbe-server\n├── ironsbe-client\n└── ironsbe-marketdata\n\nironsbe-server\n├── ironsbe-core\n├── ironsbe-channel\n└── ironsbe-transport\n\nironsbe-client\n├── ironsbe-core\n├── ironsbe-channel\n└── ironsbe-transport\n\nironsbe-codegen\n├── ironsbe-core\n└── ironsbe-schema\n```\n\n---\n\n## Examples\n\n### Running the Examples\n\nIronSBE includes working server and client examples:\n\n```bash\n# Terminal 1: Start the server\ncd ironsbe \u0026\u0026 cargo run --example server\n\n# Terminal 2: Run the client\ncd ironsbe \u0026\u0026 cargo run --example client\n```\n\n**Expected output:**\n\nServer:\n```\nStarting IronSBE server on 127.0.0.1:9000\n[Server] Session 1 connected\n[Server] Message #1 from session 1: template_id=101, size=45 bytes\n[Server] Message #2 from session 1: template_id=102, size=45 bytes\n...\n[Server] Session 1 disconnected\n```\n\nClient:\n```\nConnecting to IronSBE server at 127.0.0.1:9000\n[Client] Connected to server\n[Client] Sent message #1\n[Client] Received response: 45 bytes\n[Client] Response payload: Hello from IronSBE client! Message #1\n...\nClient stopped\n```\n\n### TCP Echo Server\n\n```rust\nuse ironsbe_core::header::MessageHeader;\nuse ironsbe_server::builder::ServerBuilder;\nuse ironsbe_server::handler::{MessageHandler, Responder};\nuse std::net::SocketAddr;\nuse std::sync::atomic::{AtomicU64, Ordering};\n\nstruct EchoHandler {\n    message_count: AtomicU64,\n}\n\nimpl MessageHandler for EchoHandler {\n    fn on_message(\n        \u0026self,\n        session_id: u64,\n        header: \u0026MessageHeader,\n        buffer: \u0026[u8],\n        responder: \u0026dyn Responder,\n    ) {\n        let count = self.message_count.fetch_add(1, Ordering::Relaxed) + 1;\n        println!(\n            \"Message #{} from session {}: template_id={}, size={} bytes\",\n            count, session_id, header.template_id, buffer.len()\n        );\n        \n        // Echo the message back\n        responder.send(buffer).ok();\n    }\n\n    fn on_session_start(\u0026self, session_id: u64) {\n        println!(\"Session {} connected\", session_id);\n    }\n\n    fn on_session_end(\u0026self, session_id: u64) {\n        println!(\"Session {} disconnected\", session_id);\n    }\n}\n\n#[tokio::main]\nasync fn main() -\u003e Result\u003c(), Box\u003cdyn std::error::Error\u003e\u003e {\n    let addr: SocketAddr = \"127.0.0.1:9000\".parse()?;\n    let handler = EchoHandler { message_count: AtomicU64::new(0) };\n\n    let (mut server, handle) = ServerBuilder::new()\n        .bind(addr)\n        .handler(handler)\n        .max_connections(100)\n        .build();\n\n    // Handle Ctrl+C for graceful shutdown\n    let shutdown_handle = std::sync::Arc::new(handle);\n    let sh = shutdown_handle.clone();\n    tokio::spawn(async move {\n        tokio::signal::ctrl_c().await.ok();\n        sh.shutdown();\n    });\n\n    server.run().await?;\n    Ok(())\n}\n```\n\n### TCP Client\n\n```rust\nuse ironsbe_client::builder::{ClientBuilder, ClientEvent};\nuse ironsbe_core::buffer::{AlignedBuffer, ReadBuffer, WriteBuffer};\nuse ironsbe_core::header::MessageHeader;\nuse std::net::SocketAddr;\nuse std::time::Duration;\n\nfn create_message(template_id: u16, payload: \u0026[u8]) -\u003e Vec\u003cu8\u003e {\n    let mut buffer = AlignedBuffer::\u003c256\u003e::new();\n    let header = MessageHeader::new(payload.len() as u16, template_id, 1, 1);\n    header.encode(\u0026mut buffer, 0);\n    \n    let header_size = MessageHeader::ENCODED_LENGTH;\n    buffer.as_mut_slice()[header_size..header_size + payload.len()]\n        .copy_from_slice(payload);\n    \n    buffer.as_slice()[..header_size + payload.len()].to_vec()\n}\n\n#[tokio::main]\nasync fn main() -\u003e Result\u003c(), Box\u003cdyn std::error::Error\u003e\u003e {\n    let addr: SocketAddr = \"127.0.0.1:9000\".parse()?;\n\n    let (mut client, mut handle) = ClientBuilder::new(addr)\n        .connect_timeout(Duration::from_secs(5))\n        .max_reconnect_attempts(3)\n        .build();\n\n    // Run client in background\n    tokio::spawn(async move { client.run().await });\n    tokio::time::sleep(Duration::from_millis(100)).await;\n\n    // Send messages\n    for i in 1..=5 {\n        let payload = format!(\"Hello from client! Message #{}\", i);\n        let message = create_message(100 + i as u16, payload.as_bytes());\n        handle.send(message)?;\n        \n        // Poll for responses\n        while let Some(event) = handle.poll() {\n            match event {\n                ClientEvent::Message(data) =\u003e {\n                    println!(\"Received: {} bytes\", data.len());\n                }\n                ClientEvent::Connected =\u003e println!(\"Connected\"),\n                ClientEvent::Disconnected =\u003e println!(\"Disconnected\"),\n                ClientEvent::Error(e) =\u003e eprintln!(\"Error: {}\", e),\n            }\n        }\n        \n        tokio::time::sleep(Duration::from_millis(100)).await;\n    }\n\n    handle.disconnect();\n    Ok(())\n}\n```\n\n### SPSC Channel (Ultra-Low Latency)\n\n```rust\nuse ironsbe_channel::spsc;\n\nfn main() {\n    // Create a lock-free SPSC channel\n    let (mut tx, mut rx) = spsc::channel::\u003cu64\u003e(4096);\n    \n    // Producer thread\n    std::thread::spawn(move || {\n        for i in 0..1_000_000 {\n            // ~12ns send latency\n            while tx.send(i).is_err() {\n                std::hint::spin_loop();\n            }\n        }\n    });\n    \n    // Consumer thread - busy-poll for lowest latency\n    let mut count = 0u64;\n    loop {\n        if let Some(value) = rx.recv() {\n            count += 1;\n            if count \u003e= 1_000_000 {\n                break;\n            }\n        }\n    }\n    \n    println!(\"Received {} messages\", count);\n}\n```\n\n### Broadcast Channel\n\n```rust\nuse ironsbe_channel::broadcast::BroadcastChannel;\n\nfn main() {\n    let channel = BroadcastChannel::\u003cu64\u003e::new(1024);\n    \n    // Create multiple subscribers\n    let mut sub1 = channel.subscribe();\n    let mut sub2 = channel.subscribe();\n    \n    // Publish messages\n    channel.send(42);\n    channel.send(100);\n    \n    // All subscribers receive all messages\n    assert_eq!(sub1.recv(), Some(42));\n    assert_eq!(sub2.recv(), Some(42));\n    assert_eq!(sub1.recv(), Some(100));\n    assert_eq!(sub2.recv(), Some(100));\n}\n```\n\n---\n\n## Supported SBE Features\n\n| Feature | Status |\n|---------|--------|\n| Primitive types (int8-64, uint8-64, float, double, char) | ✅ |\n| Fixed-length arrays | ✅ |\n| Enums | ✅ |\n| Bitsets (sets) | ✅ |\n| Composite types | ✅ |\n| Repeating groups | ✅ |\n| Nested repeating groups | ✅ |\n| Variable-length data | ✅ |\n| Optional fields (null values) | ✅ |\n| Schema versioning | ✅ |\n| Little-endian byte order | ✅ |\n| Big-endian byte order | ✅ |\n| Message header customization | ✅ |\n| Constant fields | ✅ |\n\n---\n\n## System Requirements\n\n### Minimum\n- Rust 1.75+\n- Linux, macOS, or Windows\n\n### Recommended for Production\n- Linux kernel 5.10+ (for io_uring support)\n- CPU with AVX2 support\n- Dedicated CPU cores (isolcpus)\n- 10GbE+ network interface\n- Kernel bypass capable NIC (optional)\n\n### System Tuning\n\n```bash\n# CPU performance mode\necho performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor\n\n# Network tuning\nsudo sysctl -w net.core.busy_read=50\nsudo sysctl -w net.core.busy_poll=50\nsudo sysctl -w net.core.rmem_max=16777216\n\n# NIC tuning (disable interrupt coalescing)\nsudo ethtool -C eth0 rx-usecs 0 tx-usecs 0\n```\n\n---\n\n## Documentation\n\n- [API Reference](https://docs.rs/ironsbe)\n- [Architecture Guide](doc/architecture.md)\n- [Examples](ironsbe/examples/)\n\n---\n\n## Development\n\n### Prerequisites\n\n- Rust 1.85+ (Edition 2024)\n- Cargo\n\n### Building\n\n```bash\ngit clone https://github.com/joaquinbejar/IronSBE.git\ncd IronSBE\n\n# Build all crates\ncargo build --workspace\n\n# Run tests\ncargo test --workspace\n\n# Run linting\ncargo clippy --all-targets --all-features -- -D warnings\n\n# Format code\ncargo fmt --all\n\n# Generate documentation\ncargo doc --workspace --no-deps --open\n```\n\n### Using the Makefile\n\nThe project includes a comprehensive Makefile:\n\n```bash\n# Format and lint\nmake fmt\nmake lint\n\n# Run tests\nmake test\n\n# Pre-push checks (recommended before committing)\nmake pre-push\n\n# Run benchmarks\nmake bench\n\n# Generate documentation\nmake doc\n\n# Set version across all crates\nmake version VERSION=0.2.0\n\n# Publish all crates to crates.io (in dependency order)\nmake publish-all\n```\n\n### Running Examples\n\n```bash\n# Run the server example\ncd ironsbe \u0026\u0026 cargo run --example server\n\n# Run the client example (in another terminal)\ncd ironsbe \u0026\u0026 cargo run --example client\n```\n\n### Code Style\n\n- Follow Rust standard formatting (`cargo fmt`)\n- Pass all clippy lints (`cargo clippy -- -D warnings`)\n- Add tests for new functionality\n- Update documentation for API changes\n- All comments and documentation in English\n\n---\n\n## Contributing\n\nContributions are welcome! Please follow these steps:\n\n1. Fork the repository\n2. Create a new branch for your feature or bug fix\n3. Make your changes and ensure that the project still builds and all tests pass\n4. Run `make pre-push` to verify everything works\n5. Commit your changes and push your branch to your forked repository\n6. Submit a pull request to the main repository\n\n---\n\n## Contact\n\nIf you have any questions, issues, or would like to provide feedback, please feel free to contact the project maintainer:\n\n- **Author**: Joaquín Béjar García\n- **Email**: jb@taunais.com\n- **Telegram**: [@joaquin_bejar](https://t.me/joaquin_bejar)\n- **Repository**: \u003chttps://github.com/joaquinbejar/IronSBE\u003e\n- **Documentation**: \u003chttps://docs.rs/ironsbe\u003e\n\n---\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjoaquinbejar%2Fironsbe","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjoaquinbejar%2Fironsbe","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjoaquinbejar%2Fironsbe/lists"}