Computer Science editorial
SkelOT: Reusing AOT Compilation Across EVM Contract Families
The core problem
Ahead-of-time (AOT) compilers for the Ethereum Virtual Machine (EVM), such as revmc, evmone, and DTVM, currently reuse compilation artifacts at the granularity of a contract's code hash. This design choice assumes that each unique bytecode sequence represents a distinct compilation target. However, real EVM workloads are dominated by **contract families**: factory-, proxy-, and template-driven deployments that share instruction structure but differ only in a small set of embedded constants. Examples include ERC-20 tokens deployed from a common factory, upgradeable proxy implementations, and template-based NFT collections.
The mismatch between per-hash reuse and family-structured workloads has measurable consequences. Across four EVM chains (Base, Ethereum, BSC, and Arbitrum), the authors find that **23.1–47.6% of unique compilable bytecodes map to shared family skeletons within 10K-block windows**. Per-hash AOT therefore redundantly recompiles structurally equivalent code, inflating compile time and artifact footprint while reducing workload coverage under finite compile budgets. This paper introduces SkelOT, an AOT framework that lifts the unit of compilation reuse from code hash
Innovation
On the 10K-block Base mainnet corpus, SkelOT achieves substantial reductions in compilation overhead while preserving correctness:
- **Compilation units**: reduced by **47.5%** compared to per-hash AOT.
- **Artifact footprint**: reduced by **57.4%**.
- **Compile time**: improved by ****.
- **Execution correctness**: byte-identical execution outcomes versus per-hash AOT.
- **Runtime performance**: a ** median per-contract speedup** across family members.
Under a compile budget targeting 75% execution-time coverage, SkelOT requires far fewer artifacts than per-hash AOT, and this advantage holds at every coverage target. The family-skeleton reuse unit thus improves both the efficiency of compilation and the effective coverage achievable under finite compile budgets.
Why it matters
The results confirm that per-hash AOT is poorly matched to real EVM workloads. The prevalence of contract families—23.1–47.6% of unique compilable bytecodes within 10K-block windows across Base, Ethereum, BSC, and Arbitrum—means that per-hash compilation repeatedly processes structurally equivalent code. SkelOT's family-skeleton granularity directly addresses this redundancy.
The runtime table mechanism introduces a small indirection for variant constants, yet the measured median per-contract speedup indicates that the net effect remains positive. This is plausible because the compiled skeleton captures the dominant control-flow and arithmetic structure, while constant resolution is a comparatively cheap operation.
The compile-budget analysis is particularly relevant for production AOT deployments, where compile time and artifact storage are constrained. By reducing the number of artifacts needed to reach a given execution-time coverage, SkelOT enables broader workload coverage without proportional increases in compilation resources. The advantage persisting at every coverage target suggests the benefit is structural rather than an artifact of a specific budget point.
Limitations include evaluation on a single 10K-block Base mainnet corpus for the primary performance claims, though the family-prevalence study spans four chains. Future work could examine cross-chain artifact portability, dynamic family detection at runtime, and integration with other AOT backends beyond revmc/LLVM.
Who should read this
Opening member content…