vox 0.2.0

Vox language compiler


To use this package, run the following command in your project's root directory:

Manual usage
Put the following dependency into your project's dependences section:

Small and fast JIT/AOT compiler with zero dependencies

CI

Vox programming language

Vox is a multiparadigm programming language inspired by D (60%), Jai (30%), and Zig (10%).

Main features

  • Fast compilation
  • Strong metaprogramming
  • Can be used for scripting and standalone programs (both JIT and AOT compilation)
  • No dependencies (except D compiler)

Similarities to the D language

  • Same syntax for most portions of the language (struct, function, enum, for, while, if, UFCS, slices, arrays)
  • Conditional compilation
  • Templates, Variadic templates, and functions
  • C interoperability
  • Modules / Packages

Differences from the D language

  • No GC, minimal runtime, no classes (only structs), no exceptions
  • More compile-time features, faster CTFE
  • Using templates for heavy calculations is discouraged, instead, CTFE can be used for introspection, and code generation.
  • Macros (WIP)
  • No C++ interoperability

Platforms

Supported:

  • windows-x64 - host and target
  • linux-x64 - host and target
  • macos-x64 - only jit-mode

Planned:

  • linux-arm64
  • wasm
  • windows-arm64?
  • spirv (Vulkan/OpenCL/OpenGL shaders)

Project goals

  • Strong focus on application extensions
  • Maximize user productivity
  • Maximize application performance
  • AOT and JIT, plugin support, runtime compilation, embedded compiler, tiered compilation
  • Static typing
  • Great error messages
  • Fast / Incremental compilation
  • Minimize effort needed for installation, setup, integration
    • Minimal dependencies/encapsulate dependency into module or package
    • Runtime as a library/minimal runtime/no runtime
    • Embedding/extern C
    • Code driven compilation, extending compiler from inside of the program being compiled
  • Processor intrinsics
  • Conditional compilation
  • CTFE, Templates, Introspection, Code generation

Syntax examples

i32 fib(i32 number) {
    if (number < 1) return 0;
    if (number < 3) return 1;
    return fib(number-1) + fib(number-2);
}

struct Point {
    i32 x;
    i32 y;
}

T min[T](T a, T b) {
    if (a < b) return a;
    return b;
}

<details>

<summary>code</summary>

  // Source code
  string source = q{
      void test(i32* array, i32 index, i32 value) {
          array[index] = value;
      }
  };
  
  // Error handling is omitted
  Driver driver;
  driver.initialize(jitPasses);
  scope(exit) driver.releaseMemory;
  driver.beginCompilation();
  driver.addModule(SourceFileInfo("test", source));
  driver.compile();
  driver.markCodeAsExecutable();
  
  // Get function pointer
  auto testFun = driver.context.getFunctionPtr!(void, int*, int, int)("test");
  
  // Use compiled function
  int[2] val = [42, 56];
  testFun(val.ptr, 1, 10);
  assert(val[1] == 10);

</details>

Running & testing

In main.d uncomment one of the following lines:

//version = bench; // Runs benchmark
//version = devtest; // Run single test with fine-tuned logging. Useful for development. Uses tester.runDevTests(). Toggle options there for precise analisys while developing.
//version = test; // Runs test suite. Uses tester.runAllTests().

and run with: source> dmd -m64 -i main.d && main

Benchmarking:

ldc2 -d-version=bench -m64 -O3 -release -boundscheck=off -enable-inlining -flto=full -i main.d && main

Debug CLI build:

dmd -i -g -m64 -version=cli main.d -of=vox.exe

Release CLI build:

ldc2 -d-version=cli -m64 -O3 -release -boundscheck=off -enable-inlining -flto=full -mcpu=native -i main.d -of=vox.exe

Debug shared library build:

ldc2 -m64 -shared -g -d-debug -fvisibility=hidden -link-defaultlib-shared=false -i c_api.d -of=libvox.dll

Compiling with Profile Guided Optimization:

ldc2 -d-version=test -m64 -release -fprofile-instr-generate -mcpu=native -i main.d -of=vox_instrumented.exe
vox_instrumented
ldc-profdata merge default.profraw -output vox.profdata
ldc2 -d-version=cli -m64 -O3 -release -boundscheck=off -enable-inlining -flto=full -mcpu=native -fprofile-instr-use=vox.profdata -i main.d -of=vox.exe

Using Commandline interface

Getting help

Gives the full list of flags

vox --help

Input files

Each file must begin with --- <path>, three dashes, space, and name.

Files can be nested inside directories --- dir/dir2/file.txt.

Example:

--- main.vx
import kernel32;
void main() { ExitProcess(42); }
--- kernel32.vx
@extern(module, "kernel32")
noreturn ExitProcess(u32 uExitCode);

Can be compiled with vox program.har

CLI Tools

The compiler contains embedded tools:

PDB dump

Prints content of vox.pdb file into stdout.

vox pdb-dump vox.pdb

Syntax highlighting

GitHub

To get some syntax highlighting on GitHub define .gitattributes file in the repository with the following content (docs):

*.vx linguist-language=D

All .vx files will be highlighted and classified as D.

Editor

Compiler overview

Stats

  • Impl size: 40k LoC of D, 3MB exe
  • Time to compile: 4s debug / 45s release
  • Test suite: 95ms for 361 tests
  • Time to compile 10MLoC of fibonacci: 8s on Windows, 7.5s on Linux

For more in detail description of implementation see internals.md

Authors:
  • Andrey Penechko
Dependencies:
none
Versions:
0.2.0 2022-Apr-19
~master 2022-Jul-15
Show all 2 versions
Download Stats:
  • 0 downloads today

  • 0 downloads this week

  • 0 downloads this month

  • 2 downloads total

Score:
2.5
Short URL:
vox.dub.pm