What's been missing.

Today’s compute stack is a patchwork of isolated worlds:

• Classical digital — CPUs, GPUs, TPUs, instruction sets, tensors.
• Photonic and optical — continuous transforms, interference, amplitude and phase.
• Neuromorphic — spikes, events, temporal dynamics, emergent behavior.
• Quantum — superposition, entanglement, measurement, probabilistic collapse.

Each paradigm has its own tools, its own models, its own IRs — if it has any IR at all. They do not share a common language. They do not share a common substrate.

Under classical abstractions, none of them can be itself. Continuous optical fields are discretized. Event-driven spikes are sampled into clocked tensors. Superposition is described by a machine that can only hold one definite state at a time. To be expressed at all, each paradigm must surrender the very properties that make it powerful.

That is why they cannot coexist: the shared layer beneath them assumes one world, and forces every other world to translate into it. Compilers, runtimes, and frameworks try to bridge the gap, but they all inherit the same constraint — they begin and end in classical assumptions.

Modern IRs — LLVM IR, MLIR, ONNX, and their descendants — are extraordinary achievements. They unify compilers, structure transformations, and make large-scale software possible.

But they are built for one world:

• discrete operations
• deterministic semantics
• classical memory models
• tensor-centric or instruction-centric computation

They can simulate other paradigms. They can host dialects that approximate photonic, neuromorphic, or quantum behavior. But they cannot natively represent:

• continuous optical transforms as first-class graph semantics
• spike timing and event-driven dynamics as core execution models
• quantum superposition and measurement as fundamental state semantics
• hybrid continuous/discrete, probabilistic/causal systems in one unified graph

They are frameworks for classical machines, not substrates for heterogeneous intelligence.

What is missing is not another framework, library, or dialect system. What is missing is a substrate — a universal internal world where all architectures can exist as first-class citizens.

A layer that:

• represents classical logic, optical transforms, spikes, and superposition in one coherent graph
• defines unified semantics across discrete, continuous, probabilistic, and temporal domains
• provides canonical structure for analysis, optimization, and lowering
• is independent of any single hardware family, vendor, or paradigm
• can evolve as new architectures appear without breaking the world already built on it

This is the missing layer: the universal substrate for intelligence.

Frameworks sit on top of hardware. They adapt to what exists.

A substrate sits under everything. It defines the computational world itself.

A substrate:

• is the canonical representation of computation
• is the place where semantics are defined and preserved
• is the anchor for compilers, runtimes, and co-design loops
• is the layer that survives hardware turnover and paradigm shifts

In a world of heterogeneous compute, the substrate is no longer optional. It is the only way to keep intelligence coherent as architectures diverge.

As photonic, neuromorphic, quantum, and future architectures mature, the classical assumption breaks completely. We cannot keep translating every paradigm back into a single, aging model of computation.

At some point, the system must admit the truth:

Intelligence needs a substrate that is not bound to one machine.

HeteroIR exists to be that substrate.