Technical preprint · Version 0.1 · 9 November 2026

Ounce-Core: An Evidence-First Laboratory for Differential Verification of AArch64 Execution

Ounce-Core maintainers · Project-authored research report · Not peer reviewed

Read Markdown sourceCite this reportIndependently reproduce
Evidence boundary: results are attributed to dated repository records and CI runs. We make no assertion of a peer-reviewed study, universal AArch64 support, or an independently verified outside reproduction.

Status: Public project research report; not peer reviewed or independently replicated. Source snapshot: c7a0ed9d8b83f73d0c090d129f2d9b06e0453108. Results cited below were generated at multiple earlier commits; the snapshot is a documentation anchor, not a claim that every experiment ran at this exact commit.

Abstract

Correct execution of AArch64 software is difficult to establish when an emulator or dynamic translation engine is tested only against itself. Ounce-Core is an open-source Rust research platform that treats verification evidence—not broad compatibility or peak execution speed—as its primary output. It executes selected, pinned open-source workloads using an AArch64 interpreter, a higher-tier execution path, and, on supported ARM64 hosts, native execution, then compares observable outcomes with separately built references. The workflow records test identities, compiler inputs, bytes, failures and limitations; complementary instruction-level experiments compare selected architectural state directly with Apple Silicon hardware. We present the architecture and falsifiable test procedure, then analyze project-retained results: multiple fixed library harnesses, a bounded static Linux ELF demonstration, a single-instruction randomized study reporting 2,644,540 compared words with no mismatches in its selected state fields, and documented cross-host floating-point/status disagreements. The results are evidence of agreement on specified cases, not a proof of instruction-set completeness or application compatibility. No successful independent outside reproduction was established at the time of writing. This report offers a traceable basis for further replication and extension rather than a claim of general correctness.

Keywords: AArch64; ARM64; CPU emulation; differential testing; reproducibility; interpreters; JIT; research artifacts; executable semantics.

1. Introduction

An interpreter may report a successful program exit while silently calculating an incorrect value. Two emulation engines may agree because they share a faulty decoder or inherited semantics. Even matching an expected checksum says little if that expectation was generated by the system under test. These problems motivate an evaluation design that separates the reference observation, guest execution, and evidence record.

Ounce-Core began as a console-homebrew execution project. Its research direction is now narrower and more general: execute selected AArch64 workloads, expose and diagnose discrepancies, and retain enough information to rerun them. The system is not presented as a general-purpose Linux compatibility layer, a production sandbox, or a substitute for mature system emulators. An earlier homebrew corpus remains as a graphics-oriented regression fixture but is not the central scientific claim [5–8].

This report makes three bounded contributions:

  1. An explicit differential-verification workflow for pinned programs and selected A64 instruction cases, with distinct reference and emulator channels.
  2. An audit trail joining workload identity, engine-specific outputs, negative outcomes and reproducibility instructions.
  3. A case-study analysis of recorded successes, discovered defects, test exclusions and host-dependent disagreements.

The paper is a project-authored technical preprint. Its evidential distinction is crucial: repository records and GitHub CI provide inspectable internal evidence, while an unaffiliated rerun and peer review remain outstanding.

Bellard's QEMU describes portable dynamic translation as a way to execute software across architectures and operating-system environments [1]. Ounce-Core does not claim comparable breadth, performance or maturity; its present study concentrates on instrumented, limited workloads and evidence preservation.

Differential testing is established in compiler validation. Csmith's randomized programs exposed wrong-code behaviour in production C compilers while attending to undefined behaviour [2]. Equivalence Modulo Inputs uses related executions to evaluate optimizer transformations [3]. Ounce-Core applies the broader independent observations expose implementation errors principle to emulated AArch64 state and application outputs, without claiming to implement Csmith or EMI itself. The normative meaning of A64 instruction encodings comes from Arm's architectural documentation, not the output of one particular processor [4]. Hardware agreement is consequently a useful oracle only where architecture-defined behaviour and host/compiler assumptions are understood.

3. System and Trust Boundaries

3.1 Execution and reference paths

For a pinned upstream program, the project builds a native reference executable and a separately targeted guest harness around the same input cases. The guest is run under Ounce-Core's supported execution engines; each observed output is compared byte for byte with the freshly generated host result. The script also compares a committed reference file against the current host output, exposing reference drift [6, 7].

The principal differential engines are Tier-3, a decoded/fused-block execution path, and Tier-4, an optional native-JIT path. Where supported, native runs guest code on the actual ARM64 host CPU: it checks the harness/loader/toolchain pathway but is not an independent test of emulator semantics. The separate historical first-frame corpus compares the interpreter and Tier-3 against registered pixel oracles; it must not be pooled with Tier-4 or native results [5, 7, 8].

The method can be summarized as:

Pinned upstream source + fixed test cases
               |
          host build --------------------> fresh reference bytes
               |
          guest build --> NRO/ELF --> Tier-3 / Tier-4 --> observed bytes
                                               |
                          comparison, stop reason, hashes and logs
                                               |
                          identical / different / skipped / blocked

3.2 Evidence does not inherit authority from a passing engine

Ounce-Verify validates structured records and registered oracles. Where supplied with an artifact root, it hashes referenced binary artifacts and checks that bytes match declared SHA-256 digests. It rejects malformed or contradictory evidence, incomplete mandatory coverage and mismatched identities. A valid hash establishes byte identity relative to its declared digest; it does not by itself establish independent provenance, source reproducibility, legal clearance or semantic correctness [5]. A clean process exit and a matching emulator-to-emulator result also do not establish a valid real-hardware reference.

3.3 Scope of executable inputs

The original program harnesses are AArch64 NRO workloads, generally built with devkitA64. An experimental run-elf command accepts a constrained static, little-endian AArch64 Linux ELF64 ET_EXEC subset. Its syscall model and memory semantics are incomplete; dynamic/PIE binaries, unrestricted files, networking, threading and broad libc compatibility are outside the established envelope [9]. A library built with an adapter or shim is not automatically equivalent to running an arbitrary upstream Linux binary.

4. Experimental Method

4.1 Program-harness protocol

The project manifest identifies selected upstream Git revisions or SHA-256-checked archives, the files imported, common test cases and build entry points. The reproducibility script fetches sources, builds the reference with the local host toolchain, optionally builds NROs with devkitA64, executes selected engines and compares results.txt byte for byte. A JSON summary records the host architecture, pass/failure status, per-engine results and generated NRO digests. A skipped run is not recoded as a pass [6, 7].

This is an observational equivalence test on fixed cases. It is not formal equivalence of program traces, and shared harness bugs can remain invisible. Compiler versions, source hashes, effective host ISA and engine selection must therefore accompany any result.

4.2 Instruction-state protocol

The separate single-instruction fuzzer samples instruction words in selected Advanced SIMD/scalar floating-point encodings and biases register inputs toward boundary values, NaNs, infinities, denormals, aliases and random patterns. On Apple Silicon, generated instructions run in an executable memory page and a trace captures hardware state. The replay tool submits the same input to emulator engines. The documented comparisons cover selected X/V registers, NZCV and FPSR.QC. macOS-reserved X18 is excluded; cumulative FPSR exception flags are counted separately rather than treated as comparable because they are not modeled. Host-undefined encodings and unimplemented decoder classes are classified separately [10].

Thus a reported zero-mismatch count is conditional on the instruction population actually executed and compared, the selected architectural fields and the specified FPCR configuration.

4.3 Failure and reproducibility protocol

Tests are expected to distinguish an engine mismatch, a changed host reference, unsupported encoding, rejected binary, instruction-budget exhaustion and missing prerequisites. The retained records contain enough command arguments, toolchain/host information and digests for an investigator to rerun a bounded scenario. The published guide invites unaffiliated ARM64 owners to return a fresh JSON report and mismatches, not just successful screenshots [5–7].

5. Recorded Results

All observations in this section are project-reported, dated internal artifacts unless a linked CI run is explicitly identified. We did not perform a fresh independent executable rerun for this paper. The outcomes below represent different test families and must not be added into one aggregate 'compatibility rate'.

Study or workloadReported observationWhat the observation does not establish
Selected AArch64 single-instruction study8,000,000 generated words across eight seeds; 3,222,340 hardware-executed words; 577,800 Unimplemented; 2,644,540 executed-and-compared words with zero mismatches in selected state fields [10].Full ISA coverage, arbitrary programs, other FPCR modes or FPSR exception-flag equivalence.
Hosted Apple Silicon tier checkA successful 8 Nov 2026 CI job contains a 20,000-word hardware replay and three 20,000-word engine-to-engine comparisons as described by the project [10, 12].Independent external replication or exhaustive instruction semantics.
Library differential harnessesProject records report matching bounded reference output for pinned LZ4, xxHash, SQLite, Lua and other manifest cases, including bugs found while bringing the engines into agreement [6, 7, 11].All inputs of the libraries, semantic security of cryptographic workloads, or arbitrary app support.
Static Linux AArch64 ELF: LZ4A 406-byte output matched a Linux host reference with fails=0 on Tier-3 and actual Tier-4 after 3,862,822 guest instructions; three-host workflow completed successfully on 8 Nov 2026 [9, 13].A single portable binary tested unchanged on every host, or general musl/ELF compatibility.
Additional static ELF harnessesOn an internal Linux run dated 9 Nov, xxHash, cJSON and zlib cases matched their native host references; retained reports list instruction counts of 247,981; 42,830,459; and 313,690,936 respectively [9].A claim that all those cases were independently executed and reviewed by the paper authors on multiple hosts.
Legacy first-frame corpusThe canonical CI run on 7 Nov completed successfully and the repository reports 50/50 registered first-frame scenarios for its specified interpreter/Tier-3 policy [5, 14].Program completion, gameplay, all GPU behaviour, independent rerun or console compatibility.
Cross-host discrepancyA Linux ARM64 CI run on 8 Nov failed against some Apple Silicon expected results, including FPSR high bits and NaN operand propagation; the project documented rather than silently normalizing those differences [11, 15].That every difference is an emulator bug or that one host defines the ISA for all CPUs.

5.1 Defects exposed by practical workloads

The project's retained case histories describe a prefetch instruction incorrectly interpreted as a register-writing operation, missing vector/CRC instructions, and sign or NaN-handling errors in floating-point paths. These are valuable debugging case studies: the practical workload triggered an observable difference, a focused test isolated it, and subsequent repair was checked. They do not establish a complete defect census or an unbiased benchmark of competing emulators [6, 11].

5.2 The meaning of the 8-million-word experiment

The fuzzer report partitions 8,000,000 generated words into 4,777,660 host-undefined (SIGILL) and 3,222,340 hardware-executed words. Of the latter, 577,800 were not implemented by the interpreter, leaving 2,644,540 compared and matching cases. These counts are internally arithmetically consistent. They cover a specific Advanced SIMD/scalar-FP word-space sampler and deliberately exclude unmodeled FPSR exception flags; 261,038 executed words were reported with differences in those excluded exception flags. The result is therefore zero observed mismatches among compared, implemented cases, not a zero-error rate over 8 million arbitrary A64 instructions [10].

5.3 Architecture and host differences

The 8 Nov Linux ARM64 workflow [15] is especially instructive because a failing cross-host comparison remained visible. Some mismatches can come from architecture-permitted implementation differences, toolchain operand reassociation, reference-file assumptions or emulator errors. A later merged patch pinned floating-point operand order for selected vector cases [16]; the FPSR interpretation requires careful architecture-level treatment. The correct scientific response is to retain evidence, isolate causes and update baseline expectations only with justification—not to convert every surprising result into a success.

6. Threats to Validity and Limitations

Reference validity. The host build and guest build share many source files and cases; a shared bug can produce matching but wrong outputs. Architecture-defined behaviour may permit differences that a bytewise oracle treats as failures. Host compiler version and native ABI also influence output.

Selection bias. Upstream projects and harness inputs were selected to fit a partial runtime. The instruction fuzzer samples selected encoding families, not the whole A64 architecture; rare corner cases remain underrepresented. In the corpus census, static text words also include data and zero padding, so static decoder percentages are not dynamic execution coverage [10, 17].

Execution independence. Native execution on ARM64 is a toolchain/control path. Agreement between engines may reflect common implementation errors. Independently generated expectations, fixed input identities and outside replication remain necessary.

Cross-platform generalization. The macOS/Apple Silicon reference is not a universal AArch64 oracle. Linux ARM64 host differences have been observed. ELF builds for different host operating systems need not produce identical transported executables.

Coverage gaps. FPCR rounding, flush-to-zero and default-NaN are now modelled for common FP forms and matched Linux Arm and Apple M1 hardware on the bounded fp-edge corpus; trap enables, cumulative floating-point exception flags, extensive ISA families, unrestricted Linux syscalls, security isolation, timing and full application lifecycles are not verified. A corpus first-frame pass says nothing about complete application behaviour [8–10].

Reproducibility and provenance. Retained logs, hashes and source pins make many scenarios inspectable, but do not automatically prove reproducible binary builds, third-party rights or external replication. At the paper's dated snapshot, the project explicitly requested its first unaffiliated outside rerun [5, 7, 8].

Performance and security. This is not a performance comparison, vulnerability audit, sandbox certification, or formal verification proof.

7. Reproduction and Artifact Availability

The source and experimental descriptions are public in the Ounce-Core repository at the documented snapshot. A representative NRO differential rerun requires an ARM64 macOS/Linux host, Rust, git, Python 3, a C compiler and devkitA64. Follow the live prerequisites in the reproduction guide, then record the exact commit and invoke:

git clone https://github.com/hffgzktbcc-blip/ounce-core
cd ounce-core
git checkout c7a0ed9d8b83f73d0c090d129f2d9b06e0453108
git rev-parse HEAD
cargo build --release --features "nce native-jit"
python3 scripts/verify_differential.py --nro --json differential-result.json

Inspect each harness row and any expected-different (documented) or skipped status; do not report an unqualified global pass when exceptions exist. Submit host/OS, compiler versions, SHA-256 information, first mismatches and the JSON on issue #248. To reproduce the separate bounded Linux ELF experiments, use run-elf instructions, including a static musl AArch64 toolchain and a fresh work directory. The single-instruction hardware fuzzer is macOS/Apple Silicon-specific; see its protocol.

The source code is published under the project's repository license. Third-party fixture and redistribution status is tracked separately; this paper does not assert that every historical artifact is independently provenance-cleared.

8. Research Agenda

The highest-value follow-up is an unaffiliated clean-machine rerun with a publicly inspectable input manifest, host/toolchain record, original observations and a mismatch ledger. Additional work should distinguish architecture-mandated outcomes from host-dependent behaviour, strengthen false-negative controls for the test harness, widen instruction families with explicit denominator reporting, and expose stable reports for independent tooling. A useful comparative study against another emulator would require a pre-registered suite, equivalent setup and transparent reporting of unsupported tests rather than invented speed or compatibility claims.

9. Conclusion

Ounce-Core demonstrates a practicable way to treat AArch64 execution as an experimental, evidence-bearing process: pin a program, establish an independently computed reference, execute bounded guest paths, compare outputs and preserve failure artifacts. The retained internal work shows that this approach can surface meaningful instruction and runtime discrepancies. The same records make its limitations visible: substantial unsupported instruction and operating-system behaviour, host-dependent results, and no certified outside reproduction as of 9 November 2026. Its current scientific value lies in the repeatable methodology and inspectable negative as well as positive outcomes—not a claim of complete AArch64 correctness.

References

  1. Bellard, F. (2005). QEMU, a Fast and Portable Dynamic Translator. USENIX Annual Technical Conference. https://www.usenix.org/conference/2005-usenix-annual-technical-conference/qemu-fast-and-portable-dynamic-translator
  2. Yang, X., Chen, Y., Eide, E., and Regehr, J. (2011). Finding and Understanding Bugs in C Compilers. PLDI. https://doi.org/10.1145/1993498.1993532
  3. Le, V., Afshari, M., and Su, Z. (2014). Compiler Validation via Equivalence Modulo Inputs. PLDI. https://doi.org/10.1145/2666356.2594334
  4. Arm Ltd. Learn the Architecture: A-profile / AArch64 Instruction Set Architecture. https://www.arm.com/architecture/learn-the-architecture/a-profile
  5. Ounce-Core. Ounce-Verify evidence design and corpus validation. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/verify/README.md
  6. Ounce-Core. Differential workload manifest and pinned inputs. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/verify/differential.json
  7. Ounce-Core. Reproduce the differential results. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/REPRODUCE.md
  8. Ounce-Core. What this does not prove. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/LIMITS.md
  9. Ounce-Core. Linux ELF runner and retained program reports. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/verify/linux-elf/README.md
  10. Ounce-Core. Single-instruction fuzzer: design, counts and exclusions. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/verify/insn-fuzzer/README.md
  11. Ounce-Core. Research vision and bounded results. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/VISION.md
  12. Ounce-Core CI. Apple Silicon differential verification run, 8 Nov 2026. https://github.com/hffgzktbcc-blip/ounce-core/actions/runs/42521905867
  13. Ounce-Core CI. Linux ELF LZ4 three-host run, 8 Nov 2026. https://github.com/hffgzktbcc-blip/ounce-core/actions/runs/42523628103
  14. Ounce-Core CI. Original-Switch first-frame canonical run, 7 Nov 2026. https://github.com/hffgzktbcc-blip/ounce-core/actions/runs/42380281215
  15. Ounce-Core CI. Linux ARM64 cross-host discrepancy, 8 Nov 2026. https://github.com/hffgzktbcc-blip/ounce-core/actions/runs/42501194128
  16. Ounce-Core. Pin FADD/FMUL operand order, merged PR #272. https://github.com/hffgzktbcc-blip/ounce-core/pull/272
  17. Ounce-Core. Decoder census: snapshot and padding caveats, 8 Nov 2026. https://github.com/hffgzktbcc-blip/ounce-core/blob/main/docs/verify/CENSUS_2026-11-08.md

Suggested citation

Ounce-Core maintainers. (2026). Ounce-Core: An Evidence-First Laboratory for Differential Verification of AArch64 Execution (technical preprint, version 0.1). Ounce-Core project website. https://hffgzktbcc-blip.github.io/ounce-core/research.html

Editorial note: No DOI, journal acceptance, institutional affiliation, peer-review status or independent replication is claimed. Factual corrections and independent rerun artifacts are welcome through GitHub issues.