ZeroIPC reimagines inter-process communication. Instead of treating shared memory as passive storage, it becomes an active computational substrate. Futures, lazy evaluation, reactive streams, CSP-style channels, all with zero-copy performance.

The Core Idea

Traditional IPC systems treat shared memory as a bucket for data. You serialize, copy, deserialize. Even “zero-copy” systems are often just optimized data containers.

ZeroIPC asks a different question: what if shared memory could hold not just data, but computation itself?

This shift enables:

• Futures that represent computations in progress across processes
• Lazy values that defer expensive work and share cached results
• Reactive streams with functional operators (map, filter, fold)
• CSP channels for Go-style structured concurrency

All with zero serialization overhead and language independence.

Design Philosophy

1. Minimal Metadata

ZeroIPC stores only three pieces of information per structure:

• Name: For discovery
• Offset: Where data starts
• Size: How much memory is allocated

No type information. No schema. No versioning metadata.

This enables true language independence. Python and C++ can both create, read, and write structures. Type safety is enforced per-language (C++ templates, Python NumPy dtypes).

2. Language Equality

There’s no “primary” language. All implementations are first-class:

C++ Producer:

#include <zeroipc/memory.h>
#include <zeroipc/array.h>

zeroipc::Memory mem("/sensor_data", 10*1024*1024);
zeroipc::Array<float> temps(mem, "temperature", 1000);
temps[0] = 23.5f;

Python Consumer:

from zeroipc import Memory, Array
import numpy as np

mem = Memory("/sensor_data")
temps = Array(mem, "temperature", dtype=np.float32)
print(temps[0])  # 23.5

Same binary format. No bindings. No FFI. Pure implementations following the same specification.

3. Zero Dependencies

Each implementation stands alone:

• C: Pure C99, POSIX only
• C++: Header-only, C++23
• Python: Pure Python with NumPy

No protobuf. No serialization libraries. Just direct memory access.

Traditional Data Structures

ZeroIPC provides lock-free implementations of standard structures:

These are the foundation. The interesting part is what comes next.

Codata: Computation as First-Class Structure

Data vs Codata

Data structures answer “what values are stored?”

• Array: collection of values
• Map: key-value associations
• Queue: FIFO buffer

Codata structures answer “how are values computed?”

• Future: value that will exist
• Lazy: computation deferred
• Stream: potentially infinite sequence
• Channel: communication process

ZeroIPC is (to my knowledge) one of the first IPC systems to treat codata as first-class.