Skip to content
/ zub-vm Public

A super-fast, stack-based virtual machine for dynamic languages

License

Notifications You must be signed in to change notification settings

nilq/zub-vm

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

74 Commits
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Zub VM

A super-fast, stack-based virtual machine for dynamic languages

Features

  • NaN-tagging value representation
  • Mark n' sweep garbage collection
  • Compact bytecode format
  • Easy-to-use intermediate representation

Milestones

  • Refined VM based on work by Mr Briones
  • Tracing garbage collector
  • High-level IR
  • Compilation of IR
  • Optimizer (currently 80-90% Python speed, aiming for much faster)
  • Profiler and disassembler

Example

Building IR is easy

Getting your backend up and running shouldn't have to be hard.

The following code builds IR for evaluating sum = 20.0 + 30.0:

let mut builder = IrBuilder::new();

let a = builder.number(20.0);
let b = builder.number(30.0);

let sum = builder.binary(a, BinaryOp::Add, b);

builder.bind(Binding::global("sum"), sum);

When you feel like the IR is looking smooth. Simply let VM throw it through the compiler, and run it.

let mut vm = VM::new();
vm.exec(&builder.build());

Languages

Hugorm

Hugorm is a dynamic, python-like language being built for small data science and game projects.

https://github.com/nilq/hugorm

Examples

The examples/ folder includes two small language implementations running on the ZubVM.

Atto

Atto is a functional, minimal language that showcases how little code is needed to implement a working, Turing-complete language. The syntax can be seen in the following teaser:

fn sum x is
    if = x 0
        1
    + sum - x 1 sum - x 1

fn main is
    sum 12

Mini

Mini is a simple language that looks basically like a mix of Rust and JavaScript. It covers a bit wider set of features than Atto. This does show in the size of the language though.

let bar = 13.37;

fn foo() {
  fn baz(c) {
    return c + bar;
  }
  
  return baz(10);
}

global gangster = foo();

Special thanks

About

A super-fast, stack-based virtual machine for dynamic languages

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages