EIPC — Embedded Inter-Process Communication
HMAC-SHA256 · AES-256 · < 1 ms Latency · Multi-Transport
A capability-secured, authenticated IPC fabric for EoS. Routes messages between tasks, processes, and boards with HMAC-SHA256 integrity, optional AES-256 encryption, and sub-millisecond latency across shared memory, UART, SPI, and TCP transports.
How It Works
Step-by-step flow — from initialization to output.
Define Services and Ports
Each EIPC service is identified by a name and a capability token. Services declare their input and output ports in a manifest file. EoStudio's EIPC Topology Editor can generate this manifest visually.
// eipc_manifest.h — generated by EoStudio #define EIPC_PORT_SENSOR_OUT 0x0001 #define EIPC_PORT_AI_IN 0x0002 #define EIPC_PORT_ACTUATOR_IN 0x0003 // Capability tokens (minted by kernel at boot) extern eipc_cap_t cap_sensor; extern eipc_cap_t cap_ai;
Open Ports and Connect
Tasks open EIPC ports using their capability tokens. The kernel verifies the capability before granting access. Cross-board connections use the transport layer (UART, SPI, or TCP).
// Sensor task opens output port
eipc_port_t out = eipc_port_open(EIPC_PORT_SENSOR_OUT, cap_sensor,
EIPC_DIR_SEND);
// AI task opens input port
eipc_port_t in = eipc_port_open(EIPC_PORT_AI_IN, cap_ai,
EIPC_DIR_RECV);Send and Receive Messages
Messages are sent with eipc_send() and received with eipc_recv(). The runtime automatically adds HMAC-SHA256 authentication and, if configured, AES-256-GCM encryption.
// Sensor task sends a reading
sensor_data_t data = { .temp = 23.5f, .hum = 60.2f };
eipc_send(out, &data, sizeof(data));
// AI task receives it
sensor_data_t rx;
eipc_recv(in, &rx, sizeof(rx), EIPC_WAIT_FOREVER);
printf("Temp: %.1f Hum: %.1f\n", rx.temp, rx.hum);Cross-Board Communication
For multi-board systems, EIPC transparently routes messages over UART, SPI, or TCP. The sender and receiver use the same eipc_send/recv API regardless of whether the other task is on the same chip or across a network.
// Board A: sensor node (UART transport)
eipc_transport_t t = eipc_transport_uart(UART2, 921600);
eipc_port_t remote = eipc_port_connect("board_b/ai_in", t, cap_sensor);
eipc_send(remote, &data, sizeof(data));
// Board B: AI node (receives transparently)
eipc_recv(ai_in_port, &data, sizeof(data), EIPC_WAIT_FOREVER);Usage Examples
Real-world scenarios showing EIPC in action.
A sensor node sends temperature readings to an AI anomaly detector on the same chip via shared memory EIPC.
// Sensor → EIPC (shared memory) → eAI anomaly detector
#include <eipc/eipc.h>
void sensor_task(void *arg) {
eipc_port_t out = eipc_port_open(PORT_SENSOR, cap_sensor, EIPC_DIR_SEND);
for (;;) {
float temp = read_temperature();
eipc_send(out, &temp, sizeof(float));
eos_task_delay_ms(100);
}
}
void ai_task(void *arg) {
eipc_port_t in = eipc_port_open(PORT_SENSOR, cap_ai, EIPC_DIR_RECV);
eai_model_t anomaly = eai_model_load("anomaly.eai", EAI_BACKEND_CPU);
for (;;) {
float temp;
eipc_recv(in, &temp, sizeof(float), EIPC_WAIT_FOREVER);
float score = eai_infer_scalar(anomaly, &temp);
if (score > 0.9f) alert_operator();
}
}Features
The shape of EIPC at a glance.
Capability-Based Security
Every port requires a capability token minted by the EoS kernel. No capability = no access.
HMAC-SHA256 Integrity
Every message is authenticated with HMAC-SHA256. Tampered messages are rejected before delivery.
AES-256-GCM Encryption
Optional payload encryption for sensitive data (medical, financial, defense).
4 Transports
Shared memory (same chip), UART, SPI, and TCP/IP (cross-board). Same API for all.
< 1 ms Cross-Board Latency
UART at 921600 baud delivers < 1 ms latency for 64-byte messages.
Sequence Numbers
Monotonic sequence numbers detect replay attacks and message reordering.
Zero-Copy Shared Memory
On-chip shared memory transport avoids data copies for large payloads (video, audio).
Topology Editor
EoStudio's visual EIPC topology editor generates manifests and stub code automatically.
Role in the EoS Ecosystem
Why EIPC matters — and what breaks without it.
EIPC is the communication backbone of the EoS ecosystem. Every component that needs to talk to another — eNI to eAI, eAI to actuators, eDB to eOffice, EoStudio to EoSim — does so through EIPC. It provides the security guarantees (capability tokens, HMAC integrity, AES encryption) that make multi-component EoS systems trustworthy. Without EIPC, each component would need its own ad-hoc communication protocol, making the system fragile and insecure. EIPC is the glue that turns individual EoS components into a coherent, secure system.
Depends On
Enables / Powers
Open source on GitHub
MIT licensed and developed in the open. Issues, discussions, and pull requests welcome.
In the EoS stack
EIPC is highlighted in the layer below.
Pairs well with
Sibling components that EIPC commonly works alongside.
Technical Specifications
| Integrity Algorithm | HMAC-SHA256 |
| Encryption Algorithm | AES-256-GCM (optional) |
| Transports | Shared memory, UART, SPI, TCP/IP |
| Cross-Board Latency (UART) | < 1 ms for 64-byte messages at 921600 baud |
| Cross-Board Latency (SPI) | < 100 µs for 64-byte messages at 10 MHz |
| Max Message Size | Configurable; 64 KB default; unlimited with zero-copy shared memory |
| Capability Model | Kernel-minted tokens; per-port access control |
| Wire Format | 4-byte magic + version + flags + sequence + header len + payload len + JSON header + payload |
| License | MIT |