Skip to main content
TachyonEventBridge forwards events between processes on the same machine via a single-producer/single-consumer shared-memory ring buffer (Unix-socket handshake, futex-backed wait). Tachyon’s SPSC handshake pairs one producer with one consumer, so deployments typically use one bridge instance for sending and a separate one for receiving; calling both emit() and on() on the same instance creates a self-loop on the same path.

​
Go support

TachyonEventBridge is not implemented in abxbus-go yet. Use JSONLEventBridge for the currently supported Go bridge.

​
Optional dependencies

The native Tachyon core requires GCC 14+ or Clang 17+ at install time, so it’s exposed as its own extra and intentionally left out of the bridges aggregate (which would otherwise fail to install on stock environments). Install it explicitly when you want this bridge. 
pip install "abxbus[tachyon]"
Equivalent direct install:
pip install tachyon-ipc

​
Constructor params

  • path: Unix socket path used for the SHM handshake (e.g. /tmp/abxbus.sock)
  • capacity: ring buffer size in bytes; must be a positive power of two (default 1 << 20)
  • name: optional bridge label
from abxbus.bridges import TachyonEventBridge

bridge = TachyonEventBridge('/tmp/abxbus.sock', capacity=1 << 20, name='TachyonBridge')

​
Setup with a bus

The listener side must call on(...) before any sender connects so the SHM arena/socket exist on disk. 
from abxbus import EventBus
from abxbus.bridges import TachyonEventBridge

bus = EventBus('AppBus')

# listener process
inbound = TachyonEventBridge('/tmp/abxbus.sock')
inbound.on('*', bus.emit)

# sender process (separate instance / process)
outbound = TachyonEventBridge('/tmp/abxbus.sock')
bus.on('*', outbound.emit)

​
Behavior

  • Tachyon is SPSC: a single producer is paired with a single consumer per session. Use a separate bridge instance per direction if you need bidirectional forwarding.
  • The producer disconnects from the Unix socket immediately after the SHM handshake; reconnecting after the consumer has accepted is not supported by Tachyon.
  • close() on the producer side flushes a reserved SHUTDOWN_TYPE_ID sentinel before tearing down its bus so the consumer can exit its blocking recv loop without an orphaned thread; the same shutdown wire-format is used in both runtimes, so a Python producer can cleanly shut down a TS listener and vice versa. Only the listener side unlinks the socket on disk.
  • Runtime requirements: a Linux/macOS host with futex/__ulock_wait support; Python needs tachyon-ipc, TypeScript needs @tachyon-ipc/core and Node.js.