Fluent C++ scripting.

One declaration, no glue

Bind a class once: scripts use it, saves store it, the editor reflects it.

class Spawner : public jai::property_owner<Spawner> {
public:
    JAI_PROPERTY((std::string), id, "north-gate");   // scripted and saved
    JAI_PROPERTY((int64_t), level, 1);
    JAI_SIGNAL_PROPERTY(void(int64_t), onWave);      // script-connectable, saved too
    void spawn_wave();
};

static jai::registrar<Spawner, void> _regSpawner("Spawner",
    [](jai::dynamic_binder<Spawner>& b) {
        b.method("spawn_wave", &Spawner::spawn_wave);   // a method is one line
    });

// turret.h comes from a library you can't edit
struct Turret {
    std::string name = "north";
    int64_t ammo = 10;
    void fire();
};

// your binding file: the class stays untouched
static jai::registrar<Turret, void> _regTurret("Turret",
    [](jai::dynamic_binder<Turret>& b) {
        b.constructor<>()
         .property("name", &Turret::name)   // scripted and saved
         .property("ammo", &Turret::ammo)
         .method("fire", &Turret::fire);
    });

Either way, script sees a native class (auto t = Turret(); t.ammo = 3;) and the same object saves to JSON or binary. The Dynamic Binder walks a class through being scripted, reflected, serialized and hot-reloaded with its state intact.

Two lines to hello

auto e = jai::engine::make();
e->execute("print(\"hello\");");

A static library plus headers, with no global state. jai::stdlib::register_all(e); adds formatted print, math, containers and JSON; every sample on this site assumes it.

var anything = 5;            // dynamic — the explicit, visible opt-out
anything = "now a string";   // fine; you asked for this

class Hero {
    int hp = 10;
    void heal(int amount) { hp += amount; }
}
void bump(int& x) { x += 1; }       // mutation is visible at both ends

auto h = Hero();
h.heal(5);
bump(h.hp);            // fields and elements bind by reference too
print("hp = {}", h.hp);

hp = 16

No host yet? Save it as hello.jai and run jaiscript hello.jai. jaiscript alone is a REPL, and --watch re-runs on every save (the runner, its flags). For the web, jai_spider app.jai serves the app over HTTP and applies each saved edit to the next request.

The seven pillars

The receipts

Get JaiScript

git, CMake 3.25+ and a C++20 compiler: Visual Studio 2022 or newer with the C++ workload, the Xcode command line tools, or GCC 11 / Clang 14.

curl -fsSL https://jaiscript.com/install.sh | sh

irm https://jaiscript.com/install.ps1 | iex

curl -fsSL https://jaiscript.com/install.cmd -o install.cmd && install.cmd && del install.cmd

git clone --depth 1 https://github.com/Devacor/jaiscript.git && cmake -P jaiscript/tools/install/build_runner.cmake && cmake -E chdir jaiscript build/bin/jaiscript examples/gatorquest/scripts/gatorquest.jai

To embed it: a CMake subproject, FetchContent, an installed package, or the sources dropped into a Visual Studio or Xcode project. Building JaiScript into a Host covers each route. New to Visual Studio? Visual Studio, Step by Step goes from a fresh install to a C++ program that runs a script.

Coming from another language

Language Bridges set JavaScript, C++ and C# beside JaiScript idiom by idiom. Code Migrations convert real code off Cereal, Boost.Serialization, Boost.Signals2, ChaiScript, sol2, Squirrel, pybind11, nlohmann::json, Qt properties, RTTR or a coroutine scheduler.

Who it's for

Anyone embedding scripting in a C++ engine who wants hot reload and script classes, safety rails a host tightens in a few calls, types that scale from var to strictly checked int within the same file, and behavior enforced by two implementations arguing with each other.

Built alongside a real 2D game engine, hardened by adversarial review and differential fuzzing, and dogfooded on real, playable things. The source is MIT-licensed; Stability lists what is settled before 1.0. Shipping with JaiScript inside? “Scripted with JaiScript” in your credits would be lovely to see: a request, not a condition.