kailash-enterprise 4.34.0

Kailash Enterprise — free to use · proprietary · source withheld · not open source. High-performance Rust-powered workflow engine, drop-in replacement for kailash.

Kailash Enterprise

free to use · proprietary · source withheld · not open source

High-performance Rust-powered workflow engine — a drop-in replacement for the kailash Python SDK.

kailash is the complete, open, Foundation-owned reference engine — build the whole protocol on it, free, forever. kailash-enterprise is Integrum's own optimized build of the same capability, also free to use; the one reserved right is reselling the engine itself as a rival engine.

Licence

kailash-enterprise is free to use under a proprietary, binary-only licence — you may install, run, build upon, and redistribute it bundled inside your own applications, for any purpose. It is proprietary and source-withheld (a compiled wheel; the Rust source is not distributed) and is not open source. The full terms are in LICENSE-EULA; the single reserved right is reselling the engine itself, standalone, as a rival governance engine.

Capability parity

The "same capability as kailash" statement above is a maintained fact, not a slogan: the Foundation's kailash implements the full governance/trust capability in the open (pure Python, native-independent), and parity between the two implementations is held by the cross-implementation conformance vectors under tests/parity/ and the PACT conformance vectors under crates/kailash-pact/tests/conformance/. A divergence in either is treated as a narrative-integrity incident, not merely a test failure.

Installation

pip install kailash-enterprise

Replaces pip install kailash. Existing code works without changes.

Usage

# Existing kailash code — no changes needed
from kailash.runtime import LocalRuntime
from kailash.workflow.builder import WorkflowBuilder

builder = WorkflowBuilder()
builder.add_node("NoOpNode", "step1")
workflow = builder.build()

runtime = LocalRuntime()
results, run_id = runtime.execute(workflow)

Why Enterprise?

• 22–261x faster execution via compiled Rust engine
• 100–300x less memory than the pure Python SDK
• Same API — zero migration effort
• Binary-only — source code stays protected

Compatibility

Full backward compatibility with kailash v0.12. The legacy API emits deprecation warnings to guide migration to the new v2 API.

New v2 API:

import kailash

reg = kailash.NodeRegistry()
builder = kailash.WorkflowBuilder()
builder.add_node("NoOpNode", "step1")
workflow = builder.build(reg)

runtime = kailash.Runtime(reg)
result = runtime.execute(workflow)
# result["results"], result["run_id"], result["metadata"]

Domain event bus (kailash.events)

A pluggable publish/subscribe event bus for cross-service domain events, with structured envelopes (correlation/causation tracking, schema version, JSON payload). Distinct from kailash.EventBus (which is the Nexus lifecycle broadcast bus and is unchanged).

from kailash.events import EventBus, DomainEvent

bus = EventBus()
received = []
bus.subscribe("orders", lambda e: received.append(e))

event = DomainEvent(
    "order.created", "orders", "checkout-service", {"order_id": 42}
).with_correlation("44444444-4444-4444-8444-444444444444")
bus.publish(event)

time.sleep(0.05)

Each subscriber receives a dict with the event's fields (id, event_type, topic, actor, schema_version, correlation_id, causation_id, timestamp, payload, metadata).

Choosing an event-bus backend

kailash.events ships two backends. They are not unified — the choice is a deployment-topology decision, not a convenience toggle:

Backend	Delivery scope	Durability	When to use
InMemoryEventBus	Same Python process ONLY	None	Dev / test / single-process. EventBus is an alias for this.
NatsEventBus	Cross-process, cross-host	At-least-once	Multi-process / multi-service production (requires a NATS JetStream broker).

Cross-process divergence is deliberate and silent if mis-chosen: a subscriber registered in one process on InMemoryEventBus will NEVER see events published from a different process — that is a no-delivery, not a degraded delivery. Pick NatsEventBus whenever publisher and subscriber are not the same OS process:

import os
from kailash.events import NatsEventBus, DomainEvent

# URL threaded in explicitly — the binding never reads the environment
# itself. TLS is required by default; allow_plaintext=True is only for a
# localhost test broker.
bus = NatsEventBus(os.environ["KAILASH_NATS_URL"])
bus.subscribe("kailash.events.acme.orders.created", lambda e: ...)
bus.publish(
    DomainEvent("order.created", "kailash.events.acme.orders.created",
                "checkout-service", {"order_id": 42})
)
bus.shutdown()

NatsEventBus delivers at-least-once via JetStream durable consumers; subjects MUST live under kailash.events.<tenant>.<domain>.<event> (the broker's stream captures that subtree for tenant-isolated routing).