The substrate, defined.

HeteroIR is a graph-native, paradigm-neutral computational substrate.

It represents computation as a graph — operations, relationships, and the movement of state — and it does so without privileging any single model of how a machine must work. Classical assumptions are not baked into its foundation. They are simply one possibility among many.

It is not built on top of one kind of computer. It is the world in which every kind of computer can be described.

Where a classical IR begins by asking how to compile for a processor, HeteroIR begins by asking what computation itself is — and then lets each architecture inhabit that structure on its own terms.

Inside HeteroIR, the paradigms that today live in separate, incompatible stacks are expressed together, natively, in a single internal world:

• Classical digital logic — discrete operations, instruction and tensor semantics, deterministic control.
• Photonic transforms — continuous amplitude and phase, interference, optical propagation.
• Neuromorphic spike dynamics — events, timing, and temporal behavior as first-class execution.
• Quantum operations — superposition, entanglement, and measurement as fundamental state.
• Future architectures — models not yet invented, added to the same graph without rupture.

They are not approximated into one another. They are not translated down to a common denominator. Each is represented as what it actually is, in the same coherent structure.

To understand the substrate, it helps to be precise about what it is not.

• Not a framework — it does not sit on top of hardware and adapt to what already exists.
• Not a dialect system — it does not bolt approximations of other paradigms onto a classical core.
• Not a classical IR — it does not begin and end in discrete, deterministic, silicon-shaped assumptions.

It is the substrate beneath all of them.

Frameworks, dialects, and classical IRs can be expressed within HeteroIR — but HeteroIR is not one of them. It is the layer they would each stand upon.

A substrate is only as coherent as its semantics. HeteroIR defines meaning uniformly across domains that classical representations treat as foreign to one another:

• Discrete — exact operations, logic, and instruction-level behavior.
• Continuous — optical fields and analog transforms as native quantities.
• Probabilistic — superposition, measurement, and outcomes described directly.
• Temporal — spikes, events, and causal timing as core semantics.

Because these domains share one internal world, every architecture becomes a first-class citizen of the same computational space — able to interoperate, compose, and coexist without being forced to pretend it is something else.

HeteroIR provides a canonical structure for computation — a single, well-defined form that tools can reason about with confidence.

That structure is the anchor for the work that turns intention into execution:

• analysis — understanding what a computation means and requires
• optimization — transforming it while preserving its semantics
• lowering — mapping it onto concrete hardware, whatever that hardware is

Critically, this structure is independent of any single hardware family, vendor, or paradigm. No processor, accelerator, or physical medium owns it.

It is built to evolve — as new architectures appear, they join the substrate rather than break it.