The road to Wolang 1.0, inside MowoEngine
Wolang 1.0 has a concrete definition: an actor written in Wolang, with Tick, components and hot reload, that ships in a release build of a MowoEngine game without leaks. Most of the road is already behind us: embedding, hot reload that keeps state, a debugger, a sandbox for mods and bindings generated from engine reflection. Here is what is done and what is left.

"1.0" can mean almost anything. For Wolang it means one specific thing:
You can write an actor in Wolang in MowoEngine, with
Tick, components and hot reload, without leaks, and ship it in a release build.
The language and the engine host are one line of work, not two tracks. Until the host exists, there is no 1.0. Here is where that road stands.
Done: embedding
Wolang embeds through one C header, a C ABI, and a static or shared library:
#include "wolang/embed/wolang.h"
WolangVm* vm = wolang_vm_create();
wolang_vm_bind(vm, "host_log", (void*)&host_log);
wolang_vm_load(vm, "scripts/enemy");
WolangValue delta = wolang_float(1.0 / 60.0), out;
wolang_vm_call(vm, "Update", &delta, 1, &out);CMake users get it with find_package(Wolang CONFIG) and Wolang::embed. Host objects cross the boundary as opaque handles (extern class): the host keeps the reference count, and a weak var on the Wolang side asks the host whether the object is still alive. A VM accepts calls from any thread, one at a time, so you can run one VM per worker.
Done: hot reload that keeps state
wolang_vm_reload swaps in new code and keeps the program's state: module-level variables and live objects are carried over by name when the shape of their type still matches. Function handles stay valid by name. If a class gains or loses fields, matching fields carry over and the rest is reported in wolang_vm_notes instead of crashing.
That is the property that matters in an editor. You change a script while the game is running and keep playing from where you were.
Done: a debugger
wolang dap speaks the Debug Adapter Protocol, so breakpoints, stepping, the call stack, locals and object fields work in VS Code and any other DAP client. Inside an engine, wolang_vm_debug_listen lets the debugger attach to a running game. Debugging runs on the reference interpreter, the same tier the differential fuzzer checks the compiled tiers against.
Done: a sandbox for mods
extern is only allowed in trusted packages. Every primitive declares its capability (uses io, net, time, rand), and wrapping a primitive cannot hide it. A host loads a mod with wolang_vm_load_mod(vm, path, caps): the host decides what the mod may do, the mod's manifest can only narrow that, and unsafe and native linking are refused outright.
Done: bindings from engine reflection
wolang bind --reflection reads MowoEngine's reflection data and writes a Wolang package plus the C++ glue. Today that is 165 classes, 734 functions and 256 properties, the same metadata that drives the Visual Scripting node catalogue. When the engine gains a reflected function, Wolang gains it too.
Done: a benchmark
1,000 actors ticking every frame:
| Tier | Time relative to C++ |
|---|---|
| AOT (LLVM) | 1.7× |
| Dev tier (JIT) | 11× |
| Interpreter | about 1,400×, used only under the debugger |
Shipped games use AOT, development uses the dev tier, and the interpreter is for stepping through code. The benchmark lives in benchmarks/actors.
Left: the engine side
What remains happens in the MowoEngine repository:
- A bridge to
MObjectand actors: handles, roots, weak references, method calls, reading and writing reflected properties. - Wolang
componentandsystemdeclarations mapped onto the engine's ECS. - The editor: a "Wolang (Preview)" project template, creating classes from the Content Browser, errors in the Message Log, reload during Play-in-Editor, DAP debugging, and LSP support in VS Code and Rider.
mbt packagecompiling scripts ahead of time, so a release build contains no JIT.- The proof: a vertical slice with a whole level in Wolang, no leaks under AddressSanitizer and LeakSanitizer, and reloads during Play-in-Editor. We will also compare it with Visual Scripting.
Left: the language side
Mostly memory. Classes are reference counted, and the leaks we found were closed one by one, but a cycle still leaks unless it is broken with weak. Owned<T> and Shared<T> still need move tracking everywhere in lowering. We will add a cycle collector only if the actor benchmarks show we cannot do without one.
After 1.0
SPMD foreach, vectorisation with alias analysis, full WebAssembly, HTTP/2 and HTTP/3, version ranges for dependencies and Windows on arm64. Several of these are open for contributors right now. The list is in CONTRIBUTING.md.
Follow along on GitHub. STATUS.md is updated as items are crossed off.