grimoire 0.5.2

A fast, concurrent based scripting language for D

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:


Grimoire is a simple and fast concurrent programming language that can easily be embedded into another D programs. You can very easily interface your program with Grimoire's scripts.

Hope you have fun with this project !

Documentation here !

What it looks like:

//Hello World
action main {
    trace("Hello World!");
//Invert a string
action main {
    assert("Hello World !":invert == "! dlroW olleH");

function invert(string str) (string) {
    let result = str as list(string);
    loop(i, result:size / 2)
        result[i], result[-(i + 1)] = result[-(i + 1)], result[i];
    return result as string;
action fib {
        function(int n) (int) {
            if(n < 2) return n;
            return self(n - 1) + self(n - 2);
        }(10) == 55);


Use dub to include grimoire in your project (or just dump the files in your project if you want). Open the "test" folder to see how to add Grimoire to your program or copy/paste it.

Grimoire is in 2 parts:

  • The compiler
  • The runtime


To bind functions defined in D and add other types, you can create a GrLibrary which will store primitives and type information. The GrLibrary object can be shared between multiple compilations.

To compile, you need a compiler GrCompiler which will turn your scripts into bytecode with compileFile.

You must add the GrLibrary objects to the compiler before calling compileFile witch addLibrary. If the compilation fails, you can fetch the error with getError().

If it's successful, the compileFile function will returns a GrBytecode that stores the bytecode generated by the compiler, which can be saved into a file or run by the VM.

// Some basic functions are provided by the default library.
GrLibrary stdlib = grLoadStdLibrary(); 

GrCompiler compiler = new GrCompiler;

// We add the default library.

// We compile the file.
GrBytecode bytecode = compiler.compileFile("");

if(bytecode) {
    // Compilation successful
else {
    // Error while compiling
    import std.stdio: writeln;

Debug & Profiling

You can see the generated bytecode with


Which formats the bytecode in a printable way.

Grimoire also provide a basic profiling tool, to use it, to need to specify a flag during compilation to activate debug informations.

compiler.compileFile("", GrCompiler.Flags.profile);

The profiling information are accessible on the GrEngine with:


An already formatted version is accessible with:



Then, create the runtime's virtual machine GrEngine, you'll first need to add the same libraries as the compiler and in the same order. Then, load the bytecode.

GrEngine engine = new GrEngine;

You can then spawn any action like this:

auto mangledName = grMangleComposite("myAction", [grString]);
if(engine.hasAction(mangledName)) {
    GrContext context = engine.callAction(mangledName);
    context.setString("Hello World!");

But be aware that every function/task/event are mangled with their signature, so use grMangleComposite to generate the correct function's name.

If the event has parameters, you must push them into the context with the setXX functions.

To run the virtual machine, just call the process function (check if there's any task(Coroutine) running though):


The program will run until all tasks are finished, if you want them to run only for one step, replace the while with if.

You can then check if there are any unhandled errors that went through the VM (Caught exceptions won't trigger that).

    writeln("Unhandled Exception: " ~ engine.panicMessage);


You can find the language documentation > here ! <

  • Enalye
Sub packages:
grimoire:test, grimoire:unittests
0.8.1 2023-Mar-20
0.8.0 2023-Mar-06
0.7.0 2022-Nov-29
0.6.0 2022-Nov-01
0.5.2 2022-Jan-30
Show all 32 versions
Download Stats:
  • 0 downloads today

  • 0 downloads this week

  • 2 downloads this month

  • 232 downloads total

Short URL: