AnyLang.FastIPC 0.0.1

AnyLang.FastIPC

High-performance cross-language IPC/RPC library delivering 13M+ RPC calls/s with zero-copy shared memory architecture.

Features

• 🚀 Extreme Performance: 13M+ RPC calls/s, 15M+ raw IPC messages/s
• 🌐 Cross-Language: Seamless interop between C, C#, and Python
• 🔒 Zero-Copy: Direct memory access eliminates serialization overhead
• ⚡ Low Latency: Sub-microsecond message passing
• 🔧 Battle-Tested: Production-grade reliability with comprehensive test suite
• 📦 Easy Integration: Just dotnet add package AnyLang.FastIPC and go

Installation

dotnet add package AnyLang.FastIPC

Native binaries for Linux (x64) and Windows (x64) are included automatically.

Quick Start

Simple RPC Server/Client

using AnyLang.FastIPC;
using System;

// Server side
unsafe
{
    var server = RpcNative.CreateServer("my_channel");

    while (true)
    {
        // Receive request
        void* requestPtr;
        nuint requestLen;
        ulong requestId;

        int result = RpcNative.ReceiveRequest(server, &requestPtr, &requestLen, &requestId, 1000);
        if (result == 0)
        {
            // Process request and send response
            byte[] response = ProcessRequest(requestPtr, requestLen);
            fixed (byte* respPtr = response)
            {
                RpcNative.SendResponse(server, requestId, respPtr, (nuint)response.Length);
            }
        }
    }
}

// Client side
unsafe
{
    var client = RpcNative.CreateClient("my_channel");

    byte[] request = BuildRequest();
    byte[] response;

    fixed (byte* reqPtr = request)
    {
        void* respPtr;
        nuint respLen;

        int result = RpcNative.Call(client, reqPtr, (nuint)request.Length, &respPtr, &respLen, 1000);
        if (result == 0)
        {
            response = new byte[respLen];
            Marshal.Copy((IntPtr)respPtr, response, 0, (int)respLen);
        }
    }
}

Performance Benchmarks

Linux x64 (tested on WSL2, AMD Ryzen):

• Small messages (16 bytes): 15.2M msg/s, 232 MB/s
• Large messages (1 MB): 1,674 msg/s, 1,674 MB/s
• RPC calls (multi-threaded): 13M+ calls/s

Windows x64: Native performance (not Wine/emulation)

Platform Support

Architecture

Built on zero-copy shared memory with lock-free ring buffers:

• No serialization overhead: Direct memory access
• Lock-free design: Atomic operations for synchronization
• Bounded latency: Predictable sub-microsecond performance
• Heartbeat monitoring: Automatic partner liveness detection

Language Interoperability

Write your server in C, client in Python, or any combination:

# Python client calling C# server
from anylang_fastipc import RpcClient

client = RpcClient("my_channel")
response = client.call(request_bytes, timeout_ms=1000)

// C# server handling Python client
// Same RPC protocol, zero friction

Binary Distribution

This package contains compiled native binaries only. The C source code is proprietary and available under commercial license.

Documentation

• GitHub Repository
• API Documentation: Coming soon
• Examples: See repository for complete examples

License

MIT License (for binary distribution)

C source code requires separate commercial license.

Support

Report issues at: https://github.com/yourorg/anylang-fastipc/issues

Built with performance in mind. Ship with confidence.