zAPI — Make All Programming Languages Talk to Each Other

Project Status: 🚧 Under Active Development — Core is stable; English documentation is being gradually translated. Most documentation is currently in Chinese. Please use AI/translation tools to read Chinese docs if needed.

zAPI is a cross-language RPC framework based on pure C ABI, enabling services written in 10+ languages — C++, Python, Go, Rust, Java, C#, Pascal, Node.js, and more — to call each other as easily as calling local functions.

Core Promise: No IDL, no code generation, no new protocols to learn — use your familiar language, call the world.

📦 One C ABI, Infinite Possibilities

zAPI is built on a pure C dynamic library. Any language that supports FFI can connect. No IDL, no code generation, no complex configuration — just a header file, and your functions can run across languages, processes, and machines.

// Register an API in C
static void __cdecl AddCallback(void* trigger, void* input, void* output) {
    int a, b;
    API_ReadBuffer((TDataHnd)input, &a, sizeof(a));
    API_ReadBuffer((TDataHnd)input, &b, sizeof(b));
    int sum = a + b;
    API_WriteBuffer((TDataHnd)output, &sum, sizeof(sum));
}

int main() {
    API_LoadLibrary();
    TAppHnd app = API_Create_APPHnd("Calc", "Calculator");
    API_Reg_Call(app, "add", "Add two ints", NULL, AddCallback);
    // Prepare network...
    API_Prepare_Service("0.0.0.0", "127.0.0.1:9898");
    API_Prepare_Client("127.0.0.1:9898", app);
    API_Prepare_Done();
    // This API can now be called from any language
}

🚀 Key Features

Feature	Description
🌍 10+ Language Bindings	C++, Python, Go, Rust, Java, C#, Pascal, VB.NET, Node.js, Web.js — out of the box
⚡ High Performance	IPC mode < 1ms latency, 10,000+ requests/second
🔌 Dual Communication Modes	TCP (cross-machine) + IPC (same-machine microsecond latency)
🔄 Automatic Service Discovery	C4-based service mesh with auto-registration, discovery, and load balancing
🛡️ Fault Tolerance & Reconnection	Auto-reconnect on disconnect; services re-register automatically
🧵 Full Thread Safety	All APIs (except status logging) support concurrent calls
📦 Zero-Copy Transfer	Direct internal buffer access for maximum performance
🎯 Two Call Modes	Request-Response (Call) + One-Way Notification (Notify)
🔧 Zero-Configuration Startup	Auto-generates config file on first run; tune without recompilation

🎯 Supported Languages

Language	Binding Method	Docs	Examples
C++	RAII wrapper (`API_HubTool.hpp`)	📖 Guide (CN)	7 examples
C	Explicit dynamic loading (`API_HubTool.h`)	📖 Guide (CN)	7 examples
Python	`ctypes` + `@expose` decorator	📖 Complete Guide (CN)	20+ examples
Go	CGO bindings	📖 Complete Guide (CN)	14 examples
Rust	`libloading` + RAII	📖 Guide (CN)	14 examples
Java	JNA + AutoCloseable	📖 Guide (CN)	4 examples
C#	P/Invoke + .NET 8+	📖 Complete Guide (CN)	7 examples
VB.NET	P/Invoke	📖 Guide (CN)	5 examples
Pascal (Delphi/FPC)	`external` auto-load	📖 Complete Guide (CN)	3 examples
Node.js	Python gateway proxy	📖 Architecture (CN)	1 example
Web.js (Browser)	Python gateway proxy	📖 Guide (CN)	1 example

Any language that supports the C ABI can be integrated — you can even write bindings for your own language.

🚀 5-Minute Quick Start

Step 1: Get the Dynamic Library

Download the appropriate libraries for your platform from Releases:

Platform	Core Library	IPC Dependency
Windows 64-bit	`z_api_hub64.dll`	`z_ipc_64.dll`
Linux	`libz_api_hub.so`	`libz_ipc.so`
macOS	`libz_api_hub.dylib`	`libz_ipc.dylib`

Place them in your executable directory or system library path.

Step 2: Write a Service in Python

# service.py
from api_hub import Server

app = Server("Calculator")

@app.expose("add")
def add(a: int, b: int) -> int:
    return a + b

if __name__ == "__main__":
    app.start("ipc:calc_service")
    input("Press Enter to stop...")
    app.stop()

Step 3: Write a Client in Go

package main

import (
    "fmt"
    "github.com/PassByYou888/zAPI/api_hub"
)

func main() {
    client, _ := api_hub.NewClient()
    client.PrepareClient("ipc:calc_service")
    client.PrepareDone()

    param, _ := client.CreateDataHnd("add")
    client.WriteInt32(param, 10)
    client.WriteInt32(param, 20)

    result, _ := client.Call("Calculator", param, 3000)
    sum, _ := client.ReadInt32(result)

    fmt.Printf("10 + 20 = %d\n", sum)  // Output: 10 + 20 = 30
}

Run:

# Terminal 1: Start Python service
python service.py

# Terminal 2: Run Go client
go run client.go
# Output: 10 + 20 = 30

Python service called by Go — no extra configuration needed.

📊 Performance Benchmarks

Test Environment: Intel Xeon Gold 6248 / 32GB RAM / Ubuntu 22.04

Communication Mode	Avg Latency (p50)	Max Throughput	Use Case
Same-machine IPC (named pipe)	< 0.8 ms	~12,000 req/s	Single-node microservices, edge computing
Local TCP loopback	~2.5 ms	~6,500 req/s	Development/testing environments
Cross-machine LAN TCP	~5-15 ms	Bandwidth-limited	Production distributed deployment

Comparison Reference:

Solution	Typical Latency	Overhead
zAPI (IPC)	< 1 ms	Baseline
zAPI (TCP)	~2-3 ms	+2-3 ms
gRPC (TCP)	~5-8 ms	+4-6 ms
HTTP REST (JSON)	~10-20 ms	+9-18 ms

Why so fast?

Zero-copy data transfer: API_GetBuffer() returns internal pointers directly
Binary protocol: No JSON/Protobuf encoding/decoding overhead
C-level concurrency scheduling: Callbacks execute in C thread pools, unaffected by Python/Node GILs

🌐 Full Language Interoperability Matrix

Any language client can call any language server:

Server ↓ / Client →	C++	Python	Go	Rust	Java	C#	Pascal	Node	Web
C++	✅	✅	✅	✅	✅	✅	✅	✅	✅
Python	✅	✅	✅	✅	✅	✅	✅	✅	✅
Go	✅	✅	✅	✅	✅	✅	✅	✅	✅
Rust	✅	✅	✅	✅	✅	✅	✅	✅	✅
Java	✅	✅	✅	✅	✅	✅	✅	✅	✅
C#	✅	✅	✅	✅	✅	✅	✅	✅	✅
Pascal	✅	✅	✅	✅	✅	✅	✅	✅	✅

🔒 Thread Safety & Callback Execution Context

All zAPI functions (except API_Get_Status) are fully thread-safe. You can call API_Call from thousands of threads concurrently — the library handles it all.

But pay attention to callback execution context:

Callbacks (TAPI_Call / TAPI_Notify) execute in background thread pools. This means:

❌ NEVER call API_Call or API_Notify from within a callback — may deadlock
❌ NEVER perform long-running blocking operations in callbacks
❌ NEVER directly access UI components from callbacks
✅ Recommended: Offload expensive tasks to your own worker threads asynchronously

// ❌ WRONG: Calling API_Call inside a callback
static void __cdecl BadCallback(void* trigger, void* input, void* output) {
    // DEADLOCK RISK!
    TDataHnd result = API_Call("OtherApp", input, 5000);
}

// ✅ CORRECT: Offload task asynchronously
static void __cdecl GoodCallback(void* trigger, void* input, void* output) {
    // Push request to a queue; worker thread handles it
    WorkQueue.push(input);
    // Return immediately
}

🏗️ Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    Application Layer (10+ Languages)            │
├──────────┬──────────┬──────────┬──────────┬───────────────────┤
│  C++     │  Python  │  Go      │  Rust    │  Java / C#        │
│  Pascal  │  Node.js │  Web.js  │  C       │  VB.NET           │
├──────────┴──────────┴──────────┴──────────┴───────────────────┤
│                    Unified C ABI Dynamic Library Layer          │
├─────────────────────────────────────────────────────────────────┤
│              C4 Distributed Service Mesh                        │
│            (Auto-Discovery / Load Balancing)                    │
├─────────────────────────────────────────────────────────────────┤
│         TCP        │        IPC        │   Auto Service        │
│      (Cross-node)  │  (Same-node)      │   Discovery           │
└─────────────────────────────────────────────────────────────────┘

📂 Project Structure

zAPI/
├── Binary/                # Dynamic libraries & executables
│   ├── z_api_hub64.dll    # Core dynamic library
│   └── z_ipc_64.dll       # IPC support library
├── C++/                   # C/C++ bindings + examples
├── Py/                    # Python bindings + 20+ examples
│   ├── api_hub/           # Python core bindings
│   ├── node/              # Node.js gateway
│   └── web/               # Web.js browser gateway
├── Go/                    # Go bindings + 14 examples
├── java/                  # Java bindings + JNA
├── rust/                  # Rust bindings + 14 examples
├── C#/                    # C# bindings + 7 examples
├── VB.NET/                # VB.NET bindings + 5 examples
├── pascal/                # Pascal complete documentation
└── node/                  # Node.js client examples

📖 Documentation

Quick Start (English Overview)

zAPI: Make All Languages Talk (CN) — Project overview
zAPI Empire Treasure Map (CN) — Project structure overview

Complete Guides (Chinese — Use AI/Translation Tools)

Language	Documentation
C++	API Hub Tool C++ Guide
C	API Hub Tool C Guide
Python	Master Multi-Language Interop from Zero
Go	API Hub for Go — Complete Guide
Rust	zAPI Rust Guide
Java	API Hub Java Guide
C#	API Hub Tool for C# — Complete Guide
VB.NET	VB.NET Full-Stack Domination
Pascal	API Hub Tool for Pascal — Complete Guide
Node.js	Node.js Cross-Language Call Architecture
Web.js	js_api.py Guide

Architecture Case Studies (Chinese)

🤝 Contributing

We welcome all forms of contribution:

🐛 Report bugs
💡 Suggest new features
📝 Improve documentation
🔧 Submit Pull Requests
🌍 Write bindings for more languages

📄 License

MIT License — Free to use, modify, and distribute, even for commercial projects.

⭐ Star Support

If this project helps you, please give us a Star! Your support keeps us motivated.

Make all languages talk to each other.

GitHub · Issues · Releases

Navigation Menu

Repository files navigation

zAPI — Make All Programming Languages Talk to Each Other

📦 One C ABI, Infinite Possibilities

🚀 Key Features

🎯 Supported Languages

🚀 5-Minute Quick Start

Step 1: Get the Dynamic Library

Step 2: Write a Service in Python

Step 3: Write a Client in Go

📊 Performance Benchmarks

🌐 Full Language Interoperability Matrix

🔒 Thread Safety & Callback Execution Context

🏗️ Architecture

📂 Project Structure

📖 Documentation

Quick Start (English Overview)

Complete Guides (Chinese — Use AI/Translation Tools)

Architecture Case Studies (Chinese)

🤝 Contributing

📄 License

⭐ Star Support

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
Latest commit History 9 Commits
Binary		Binary
C#		C#
C++		C++
Go		Go
Py		Py
VB.NET		VB.NET
java		java
node		node
pascal		pascal
rust		rust
LICENSE		LICENSE
readme.md		readme.md
readme_ch.md		readme_ch.md

Folders and files

Latest commit

History

Repository files navigation

zAPI — Make All Programming Languages Talk to Each Other

📦 One C ABI, Infinite Possibilities

🚀 Key Features

🎯 Supported Languages

🚀 5-Minute Quick Start

Step 1: Get the Dynamic Library

Step 2: Write a Service in Python

Step 3: Write a Client in Go

📊 Performance Benchmarks

🌐 Full Language Interoperability Matrix

🔒 Thread Safety & Callback Execution Context

🏗️ Architecture

📂 Project Structure

📖 Documentation

Quick Start (English Overview)

Complete Guides (Chinese — Use AI/Translation Tools)

Architecture Case Studies (Chinese)

🤝 Contributing

📄 License

⭐ Star Support

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages