Compile-and-Execute Architecture

• Compile-and-Execute Architecture is a design approach that separates the static compilation of structural elements from their dynamic execution on variable inputs.
• It transforms programs, workflows, or dataflow schedules into specialized executable artifacts, optimizing performance and resource usage.
• The method is applied in diverse domains such as quantum circuits, heterogeneous processors, and neural surrogates, ensuring precise runtime validation and efficiency.

Searching arXiv for recent work on compile-and-execute architectures and closely related formulations. I’m checking for arXiv entries related to compile-and-execute architecture, including recent 2025–2026 work. Compile-and-execute architecture denotes an execution organization in which a program, operator family, or workflow is first transformed into a specialized executable artifact, and the resulting artifact is then reused during execution while new inputs, parameters, or tasks are streamed through it. Across recent research, the compiled artifact may be a fixed PREP-SELECT-PREP† quantum skeleton (Peng et al., 28 Feb 2026), paired Access and Execute kernels pinned to heterogeneous cores (Weber et al., 2017), a validated typed JSON plan compiled into Python (Harikumar, 8 Apr 2026), a WebAssembly module delegated to V8’s tiered JIT (Haffner et al., 2021), a native .eln shared library for Emacs Lisp (Corallo et al., 2020), or a task-specific neural surrogate emitted from program text (Weber et al., 2024). The common decomposition is that total cost is partitioned into a compilation phase and an execution phase, often written as $$T_{\mathrm{total}} = T_{\mathrm{compile}} + T_{\mathrm{execute}}$$ (Izawa et al., 2020).

1. Core architectural principle

At its most general, a compile-and-execute architecture separates structural synthesis from repeated execution. The compile stage fixes some combination of control flow, dataflow, routing, type structure, memory layout, or executable code; the execute stage reuses that structure while varying only the inputs, coefficients, masks, geometry, or tasks. In COMPOSER, the logical two-qubit circuit topology is synthesized once and reused verbatim across a family of similarity-transformed effective Hamiltonians, with geometry, active space, and truncations absorbed by re-dialed single-qubit rotations and streamed classical parameters (Peng et al., 28 Feb 2026). In Decoupled Access-Execute on ARM big.LITTLE, the compiler partitions hot code regions into two coarse-grained kernels—Access and Execute—that are then run as coordinated, long-lived tasks on different cores (Weber et al., 2017). In PlanCompiler, a single LLM planning call produces a typed JSON plan that is statically validated and compiled into executable Python before execution runs once without any autoregressive chaining or repair loops (Harikumar, 8 Apr 2026).

The abstraction is not tied to one implementation style. Some systems treat architecture itself as a compiled artifact. AJava integrates components, connectors, ports, data structures, and behavior in a single artifact so that the architecture is code: it is parsed, type-checked, compiled, and executed, with communication and scheduling semantics upheld by the generated runtime (Haber et al., 2014). Other systems compile executable code in a more conventional sense, as in Emacs native compilation, where LAP is translated through LIMPLE and libgccjit into .eln shared libraries that are loaded dynamically (Corallo et al., 2020). Still others compile learned representations: CompILE learns to compile demonstrations into reusable latent segments and then executes the learned decoders as low-level policies under a hierarchical controller (Kipf et al., 2018), while neural surrogate compilation learns a compiler $H_\phi$ that maps program text $P$ to surrogate parameters $\theta = H_\phi(P)$, after which the small surrogate $f_\theta$ is executed repeatedly on inputs $x$ (Weber et al., 2024).

A plausible implication is that compile-and-execute is best understood as a systems pattern rather than a single compiler technology. What is compiled may be code, a circuit topology, a typed workflow graph, a dataflow schedule, a routing plan, or a learned parameterization.

2. Classes of compiled artifacts

One major class is the fixed-topology artifact. COMPOSER fixes a PREP-SELECT-PREP† skeleton, a bank of rank-one adaptors, global normalizations, and a QSP phase list; execution then updates only PREP amplitudes, local ladder phases, and masks while leaving all two-qubit wiring unchanged (Peng et al., 28 Feb 2026). Canon programs per-row finite-state machines at compile time so that high-level dataflow is encoded in LUT-backed orchestrators; runtime meta-information then drives state transitions and instruction generation without reconfiguration pauses (Bai et al., 19 Feb 2026). MACH similarly compiles a controller/worker Virtual Machine onto the Wafer Scale Engine, fixing per-PE roles, routing colors, RPC bodies, and static addresses before execution begins (Essendelft et al., 18 Jun 2025).

A second class is the generated executable artifact. OCCA keeps one kernel language, expands it at runtime into OpenMP, OpenCL, or CUDA code, compiles for the selected device, and then reuses the resulting kernel handle across launches without re-expansion or recompilation when only launch geometry changes (Medina et al., 2014). The WebAssembly SQL engine compiles physical-plan pipelines into Wasm modules, delegates execution to V8, and benefits from Liftoff for baseline execution and TurboFan for hot-tier optimization during execution (Haffner et al., 2021). Bandicoot generates fused GPU kernel sources directly at C++ compile time from expression-template ASTs and embeds those kernels into the binary, so run time only launches pre-generated kernels with actual pointers and dimensions (Curtin et al., 24 Apr 2026).

A third class is the deterministically validated workflow artifact. PlanCompiler restricts planning to a closed, typed node registry; a validator enforces node existence, edge validity, type compatibility, acyclicity, orphan detection, input arity, and required parameter presence before compilation emits Python by concatenating templates verbatim in topological order (Harikumar, 8 Apr 2026). The resulting artifact is not merely code generation; it is a statically certified execution plan over a constrained algebra of primitives.

A fourth class is the mixed or adaptive artifact. BacCaml uses a meta-hybrid JIT framework in which a meta-tracer can realize both trace-based and method-based compilation and interconnect them through Stack Hybridization (Izawa et al., 2020). Partial cross-compilation and mixed execution for dynamic binary translation emits host-native implementations plus guest-side stubs, so execution can move selectively between QEMU DBT and host-native code through ABI-aware cross-environment calling channels (Gu et al., 29 Nov 2025).

3. Execution models after compilation

The execution phase in compile-and-execute systems is not uniform; it ranges from deterministic replay of compiled structure to adaptive tiering and mixed-mode dispatch. In COMPOSER, execution applies the compiled similarity-sandwiched oracle

$$W_{\mathrm{eff}}^{(m)} = U_{\hat{\sigma}}^{(m)\dagger} W U_{\hat{\sigma}}^{(m)},$$

with masks and coefficients streamed as classical data while the two-qubit entangling pattern remains fixed (Peng et al., 28 Feb 2026). In ARM big.LITTLE DAE, execution is explicitly mapped across microarchitectures: Access runs on a LITTLE core and Execute runs on a big core, using Pthreads affinity to avoid migration overhead and exploit coherence-based reuse of prefetched data (Weber et al., 2017). In PlanCompiler, execution is a single Python subprocess with explicit dataflow through function return values, no shared mutable state, no implicit context, and no LLM calls at runtime (Harikumar, 8 Apr 2026).

Some systems deliberately rely on a runtime optimizer after compilation. The WebAssembly SQL engine compiles query plans in less than a millisecond to machine code, starts immediately in Liftoff baseline code, and then lets V8 tier up to TurboFan as execution proceeds (Haffner et al., 2021). BacCaml likewise treats compilation as online and selective: hotness thresholds trigger either trace-based or method-based compilation, after which native artifacts are dynamically loaded and invoked (Izawa et al., 2020). This shows that compile-and-execute does not require a rigid ahead-of-time boundary; the architecture can still be adaptive provided the compilation step produces an executable artifact that is subsequently run rather than interpreted.

Execution can also be distributed or architectural in the literal sense. In AJava, compiled components generally run in their own threads and communicate asynchronously through typed connectors and buffers (Haber et al., 2014). In MACH, controller PEs emit RPC wavelets and argument vectors, worker PEs react deterministically, and reduction strips implement systolic accumulation (Essendelft et al., 18 Jun 2025). In Canon, one orchestrator issues one instruction per cycle to the first PE of its row, and time-lapsed SIMD propagates that instruction through the row with deterministic staggered latency (Bai et al., 19 Feb 2026). In these systems, the compiled artifact is as much an execution topology as a code object.

4. Representative embodiments across domains

Representative embodiments span quantum algorithms, heterogeneous processors, workflow systems, databases, spatial accelerators, GPU libraries, and learned surrogates (Peng et al., 28 Feb 2026, Weber et al., 2017, Harikumar, 8 Apr 2026, Haffner et al., 2021, Bai et al., 19 Feb 2026, Essendelft et al., 18 Jun 2025, Curtin et al., 24 Apr 2026, Weber et al., 2024).

System	Compiled artifact	Execution mode
COMPOSER	Fixed PREP-SELECT-PREP† skeleton and two-qubit fabric	Re-dialed single-qubit rotations, masks, and streamed coefficients
DAE on ARM big.LITTLE	Access and Execute kernels	Access on LITTLE core, Execute on big core
PlanCompiler	Validated typed JSON plan compiled into Python	Single subprocess, no autoregressive chaining
SQL with WebAssembly	Wasm pipelines and generated library code	Liftoff baseline execution with TurboFan tier-up
Canon	Per-row FSM LUT programs and time-lapsed SIMD schedule	Runtime meta-information translated into row instructions
MACH	Controller/worker RPC layout with Tungsten and Paint outputs	Controller broadcasts wavelets; workers and reduction strips execute deterministically
Bandicoot	Compile-time fused GPU kernels	Runtime kernel launch without JIT infrastructure
Neural surrogate compilation	Program-specific surrogate weights $\theta = H_\phi(P)$	Repeated execution of lightweight $f_\theta$

These embodiments differ sharply in substrate, yet they preserve the same architectural split. Some compile control structure, some compile routeable dataflow, some compile executable code, and some compile a model parameterization. This suggests that compile-and-execute is defined less by language level than by where structural decisions are frozen and how much variability is deferred to execution.

5. Correctness, error models, and trade-offs

A recurrent theme is that compile-and-execute architectures move failure handling toward explicit validation, error budgeting, or resource accounting. PlanCompiler enforces seven deterministic checks before code generation and reports 278/300 first-pass successes overall; its residual failures are concentrated in late output-contract errors on aggregation tasks and early type mismatches at the SQLite persistence boundary (Harikumar, 8 Apr 2026). Compiler support for speculation in DAE proves sequential consistency for arbitrary reducible control flow by speculating memory requests in the access slice and poisoning mis-speculated stores in the execute slice without replays or explicit synchronization (Szafarczyk et al., 23 Jan 2025). COMPOSER makes the distinction between algorithmic and modeling accuracy explicit: block-encoding and QSP approximation errors are tunable post-compilation, whereas physical accuracy depends on the supplied parameters if they are not refined (Peng et al., 28 Feb 2026).

The fault-tolerant quantum case sharpens this resource logic. Direct Clifford+T lattice-surgery compilation first produces sliced local lattice-surgery instructions and then derives the real cadence of magic-state requests from the compiled circuit. The resulting analysis shows that variable magic state consumption rates in real circuits can cause the resource costs of magic state storage to dominate unless production is varied to suit (LeBlond et al., 2023). Here the compile-and-execute boundary does not merely improve runtime organization; it exposes a post-hoc optimization problem over distillation cadence, storage, and active volume.

The architecture also carries characteristic trade-offs. DAE on big.LITTLE can improve Execute-phase IPC by up to 37% and shift more than half of program runtime to the LITTLE core, but locking overhead scales with slice count and the lack of a shared LLC limits the benefit of prefetching across clusters (Weber et al., 2017). The WebAssembly SQL engine reduces compilation latency to under 1 ms for complex queries, but its implementation depends on Wasm’s 32-bit linear-memory model and therefore uses chunked rewiring when tables exceed 4 GiB (Haffner et al., 2021). COMPOSER guarantees zero two-qubit recompilation across instance families, but a fixed multiplexed fabric covering a pool can mean slightly larger constant factors than bespoke compilation, and angle synthesis remains a cost driver in FTQC (Peng et al., 28 Feb 2026). BacCaml demonstrates that hybrid JIT selection can outperform pure trace or pure method compilation, yet trace generation and compilation consume approximately 80% of warm-up time in the prototype (Izawa et al., 2020). Bandicoot removes runtime overhead and JIT infrastructure by compile-time fusion, but operation coverage and backend expansion remain ongoing work (Curtin et al., 24 Apr 2026).

These cases refute a common simplification: compile-and-execute does not eliminate runtime cost. It reallocates cost into different terms—synchronization, storage, factory provisioning, angle synthesis, or compile-time specialization—and makes those terms more explicit.

6. Conceptual significance and research directions

Across the literature, compile-and-execute architecture functions as a co-design principle linking representation, resource predictability, and repeated execution. In electronic structure, COMPOSER elevates operator structure control—rank-one ladders, masks, and model-space projectors—above gate-level instance-specific compilation and explicitly states that the principle extends to workloads with stable low-rank or principal-subspace structure, including embeddings, flow-equation steps, and subspace solvers such as QSE, NOQE, and GCIM (Peng et al., 28 Feb 2026). In structured LLM workflows, PlanCompiler argues that deterministic compilation over a typed registry can improve first-pass reliability and cost efficiency relative to free-form code generation (Harikumar, 8 Apr 2026). In programmable accelerators, Canon and MACH show two complementary variants: compile-time orchestration paired with runtime steering through FSMs (Bai et al., 19 Feb 2026), and a system-level Virtual Machine that fixes controller/worker roles, routing, and RPC execution on a wafer-scale device (Essendelft et al., 18 Jun 2025).

The pattern also extends into learning-based systems. CompILE compiles demonstrations into reusable latent segments and later executes those segment codes as options under sparse rewards (Kipf et al., 2018). Neural surrogate compilation explicitly separates program understanding from execution by compiling program text into surrogate weights and then executing a small network many times, yielding surrogates that are $1.9$–$H_\phi$0 as data-efficient, $H_\phi$1–$H_\phi$2 more similar to ground truth in visual tasks, and train in $H_\phi$3–$H_\phi$4 fewer epochs than surrogates trained from scratch (Weber et al., 2024). These examples suggest that the compile target need not be symbolic code at all; it can be a reusable latent policy set or a neural parameter vector.

Open problems remain domain-specific but structurally related. PlanCompiler identifies richer type distinctions, fan-in, branching, repeated nodes, and stronger SQL-surface constraints as natural extensions (Harikumar, 8 Apr 2026). Canon points to end-to-end compiler automation and optimal spatial mapping under its constraints (Bai et al., 19 Feb 2026). MACH identifies multi-wafer execution, kernel fusion, and broader hardware targets as future work (Essendelft et al., 18 Jun 2025). Emacs native compilation targets future unboxing and full tail call optimization (Corallo et al., 2020). BacCaml leaves dynamic strategy selection to future work (Izawa et al., 2020). Bandicoot continues toward HIP/ROCm, Vulkan, Metal, and additional factorization routines (Curtin et al., 24 Apr 2026).

Taken together, the literature presents compile-and-execute architecture not as a narrow compiler tactic but as a general method for converting structural variability into a reusable executable substrate. Its central promise is not that compilation makes execution trivial, but that it creates a stable object—code, circuit, workflow, schedule, or surrogate—against which execution can be organized, analyzed, and optimized with substantially greater precision than ad hoc runtime interpretation.