Skip to content

The Quokka Lua Engine (Quokka LE) is a runtime environment and transpiler for Lua bytecode.

Notifications You must be signed in to change notification settings

JaciBrunning/quokka-lua

Repository files navigation

Quokka Lua Engine

The Quokka Lua Engine (Quokka LE) is a runtime environment and transpiler for Lua bytecode.

Quokka LE is:

  • Modern
  • Cross Platform
  • Stack Optimized
#include "quokka/engine.h"
#include <iostream>

using namespace quokka::engine;

int main() {
  /**
   * # Lua program: 
   * print("Hello world, from Quokka LE!")
   */
  std::ifstream bytecode_file("my_lua_bytecode_file");
  bytecode_reader reader(bytecode_file);

  // Read a Lua program and load it into the VM.
  bytecode_chunk lua_program = reader.read_chunk();
  quokka_vm v(lua_program);

  // Define a C++ function, making it available to the Lua program
  v.define_native_function("print", [](vm &v) {
    std::cout << v.argument(0).tostring().c_str() << std::endl;
    return 0; // No return values
  });

  // Run the lua program
  v.call();
  return 0;
}

Differences from the PUC-RIO Lua VM

Feature Quokka PUC-RIO (lua.org) Notes
API C++17 C99 Quokka is built on C++17, and uses modern constructs in order to implement a modern VM.
VM Registers and Call Stack Small Vector Vector Quokka uses Small Vectors, which are pre-allocated on the stack up to a certain size. When the vector needs to grow, it is moved onto the heap. This optimizes performance and memory footprint, and is the main advantage of Quokka.
Bytecode Interpreter Any source architecture Source architecture must match running architecture Quokka can understand bytecodes compiled on different architectures, although if the architectures do not match (i.e. a 64-bit program running on 32-bit), performance during bytecode parsing can drop. Quokka offers the ability to 'transpile' bytecode between architectures, allowing you to "cross compile" lua programs. As a bonus, transpiled bytecodes will run on a standard PUC-RIO installation.
Threads Not implemented Present Quokka is optimized for embedded platforms, with small memory regions. Threading implementations, including coroutines, yields, etc, all take up a large amount of binary space and are often not required in embedded systems. Threading requirements can be met using multiple instances of quokka_vm and handling synchronization through native function declarations.
Metatables Not implemented Present Metatables are not present in Quokka at this time. They have been forgone in the interest of size optimization.
Debugging Information Removed Present* Quokka discards debugging information. *: PUC-RIO can strip bytecode information with luac -s, which is the equivilent of the Quokka bytecode parser's approach to Debugging information

About

The Quokka Lua Engine (Quokka LE) is a runtime environment and transpiler for Lua bytecode.

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages