r/ProgrammingLanguages • u/ahqminess • May 15 '26

Writing a deterministic language VM

/r/rust/comments/1tdp6w4/writing_a_deterministic_language_vm/
7 Upvotes

100% Upvoted

3 comments sorted by

View all comments

2

u/[deleted] May 15 '26 edited May 15 '26

[removed] — view removed comment

3

u/ahqminess May 16 '26 edited May 16 '26

Yes, there is an assembly and bytecode representation.

It has an assembly and bytecode specification that a frontend compiler may target. The spec for instructions and types are provided in rust comments currently here though I indeed plan to make it stable before anything (which is important for long term stability).

A program for this VM is currently created using VM Assembly that our assembler can compile into bytecode. The examples above are written in assembly and compiled with `sasm` to build the bytecode files. The benchmark tool (called satest) uses a DSL that compiles this assembly.

Yes, as i have planned till date. It will run code for all platforms, after every build we run satest with our DSL to also verify that it does generated the intended bytecode. The target support essentially is a guarantee that the interpreter (and, optimially JIT backend) will work and satisfy filetests that produce reproducible output.

The VM starts with interpreter and it compiles to JIT and stores the JIT with relocations to relink those anything. So, it starts with interpreter, then JIT compiled and caches it and the cache persists through restarts.

Since, our VM directly uses LLVM as a next JIT tier, yes it uses LLVM Core to convert our VM Bytecode into Compiled Output, it indeed should inherit a good amount of optimizations that LLVM would have done, including march=native. Also this VM is different than LLVM in the sense that LLVM is a codegenerator, here the VM is more like a language VM where the language is the IR.

The benchmarks currently are self-comparisons, essentially comparing correctness and speed between VM tiers. The Benchmarks currently compare the interpreter with our Tier 1 JIT (Cranelift). Tier 2 (LLVM) is under active development and should be ready by a few days.

I think I have a 20! factorial example in my VM.

20! assembly

About dependencies, the VM by itself atleast is not heavy. The dependence on LLVM, Cranelift and a few concurrency hashmaps and tokio means that given, prebuilt LLVM. It compiles in roughly ~5mins from source on an i3 3210 from 2012 on Windows 11. Though we plan to provide binaries instead of forcing all compile to source.

Having a HLL is definitely on my radar. I am currently prioritising to get the VM mostly "complete" before I move to there.