EIPC — Embedded Inter-Process Communication
HMAC-SHA256 · AES-256 · 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 latency that scales with the transport used — shared memory, UART, SPI, and TCP, in that relative order.
For a shorter introduction to eIPC, see the eIPC overview. This page is the engineering detail.
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.
Transport-Dependent Latency
Shared memory is fastest for same-chip messages; SPI, UART, and TCP trade latency for reach as you cross boards, in that relative order.
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. See how the pieces fit together in the EmbeddedOS ecosystem overview.
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.
Every EmbeddedOS repository, with install commands, is listed on the downloads page.
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 |
| Transport Latency Ordering | Shared memory lowest, then SPI, then UART, then TCP highest (relative order; no absolute figures published) |
| 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 |