luukdegram/luf

Statically typed, embeddable, scripting language written in Zig.

Luf

Luf is a statically typed embeddable scripting language written in Zig.

The goal of this project is to create a simple, expressive scripting language that can be used to implement new ideas. As most of it is experimental, I would currently not recommend this for any serious use.

Resources

• Examples
• Documentation
• Building from source
• Contributing
• Editor Support

Building from source

   

I try to keep up with the latest version of Zig to be able to use all of its features (and bug fixes). Currently, you'll need atleast version 0.8.0-dev.2641+55811d8da to build Luf.

Building

To build Luf as a static library, execute the following Zig command:

zig build

Tests

Currently all tests are written in Zig, but there's plans to also write behavioural tests in Luf.

To run all tests, execute the following command:

zig build test

Editor support

Currently there's support for syntax highlighting for vscode, which can be found here.

luf's Issues

Add support for calling Luf functions from Zig

• Add function's name to exported functions (so we can look them up in globals list)
• Implement the call() function
• Implement translation from Zig to Luf for call arguments

Add IR pass so we can codegen to different outputs than bytecode

Add syntax higlighting to VS Code

Make modules/imports work for new bytecode structure

Implement Garbage Collector

Add support for calling Zig functions

• Add compiler support for 'packages' for type support. (compiler doesn't know anything about this package, therefore we should ignore type checking for those cases but return a general .module type or something like that).
• Add function to value.zig to wrap a Zig function into a Luf Value.
• Add VM support to add Zig functions as a 'package'.

Implement IO in standard library

Store breaks inside a scope as index

Currently we store the whole instruction since a list, but it would save some memory if we were to simply store the index of the instruction

Implement decoder for the bytecode

Document Luf's bytecode

Implement forward declaration

This is required so we can do type checking on imported modules.

Redo compiler to emit true bytecode

Experiment: Allow compilation to typed ZIR

It would be a cool experiment to compile to typed ZIR that can be used by Zig's compiler to compile it to machine code and see its effect on performance compared to regular Zig code.

Obviously we will have to comply with Zig's semantics and type system, allowing us to only implement features that are supported by Zig. We will also have to handle memory usage someway.

Add the base for a standard library

Allocate error messages so we can format them with arguments

Currently error messages require to be comptime known, cuasing us to lose runtime known information, such as an en expected type. By allocating them we can use std.fmt.allocPrint() to make fancy error messages.

Ensure we do not forget to free all memory created by those messages. Either by deinit() or when write() is called.

Add a basic CLI for compiling/running Luf

Currently, the user would have to create their own Zig project first, and embed the VM to be able to write Luf code. Luf should also come as a standalone CLI tool that can run both Luf files as well as compiled bytecode for faster execution using flags.

Improve the test bed for Luf

Currently all tests are handwritten within Zig with a lot of expects().
This is not really manageable, and takes quite some work to update on changes.
We should look into behavioral tests.

Improve AST memory usage by utilizing @fieldParentPtr

Refactor VM to make use of the new bytecode instructions

Implement optionals

Luf already supports nil literals, but assigning nil to a variable will make its type nil as well.
Optional should be seperate type that must be handled before usage, similair to how Zig handles them.

Differentiate between public and private declarations

Function declarations should be declared as public or private by default within the global scope

Add a WASM backend

Would be cool to be able to write Luf code, and compile to WASM, rather than having to write WASM code directly. Especially because Luf has type-safety and is a lot more readable than WASM text.

Add debug symbols to bytecode

Adding support for debug symbols will allow us to print error traces for runtime errors.

Implement Errors and error handling

Imported modules have incorrect type

Currently, all imported functions have as type module. This causes errors during type checking.
This depends on #10.

Optimize simple instructions

Some instructions can easily be optimized such as:

const x = 5 + 5 can be optimized to const x = 10.
const myFunc = fn() { return 5 } can be optomized to return 5.