Wren scripts, now standalone and portable.

// high-level: hatch-aware runtime
use wren_lift::hatch_runner::HatchRunner;

fn main() -> anyhow::Result<()> {
    let mut runner = HatchRunner::new();

    // install hatch packages
    runner.install("@hatch:math")?;
    runner.install("@hatch:fp")?;

    // now run application code
    let src = r#"
        import "@hatch:math" for Vec3
        System.print(Vec3.new(1, 2, 3))
    "#;
    runner.run_source("main", src)?;

    Ok(())
}

// low-level: raw c api bindings
use wren_lift::capi::*;
use std::ffi::CString;

fn main() {
    unsafe {
        let mut cfg: WrenConfiguration = std::mem::zeroed();
        wrenInitConfiguration(&mut cfg);

        let vm = wrenNewVM(&mut cfg);
        let module = CString::new("main").unwrap();
        let src = CString::new(
            "System.print(\"hello from rust\")"
        ).unwrap();

        wrenInterpret(vm, module.as_ptr(), src.as_ptr());
        wrenFreeVM(vm);
    }
}

# Cargo.toml
[dependencies]
wren_lift = { git = "https://github.com/wrenlift/WrenLift.git", branch = "main" }
anyhow    = "1"

# build & run
$ cargo run
   Compiling wren_lift v0.1.16
   Compiling host v0.1.0
    Finished dev [unoptimized] in 4.1s
     Running `target/debug/host`
  hello, world ✦

<!-- Bare embed: one wlift.run() call. No package resolution. -->
<script type="module">
  import { createWlift } from
    "https://wrenlift.com/dist/wlift.js";

  // `mode: "main"` runs on the page thread; "worker" off-mains.
  const wlift = await createWlift({ mode: "main" });

  const { output } = await wlift.run(`
    class Greeter {
      static hello(name) { System.print("hello, %(name) ✦") }
    }
    Greeter.hello("browser")
  `);

  document.getElementById("out").textContent = output;
</script>
<pre id="out"></pre>

<!-- Hatch resolution: walk a hatchfile, fetch each @hatch:*
     package, install before the user source runs. Same flow
     the playground uses. -->
<script type="module">
  import { createWlift, runProject } from
    "https://wrenlift.com/dist/wlift.js";

  const wlift = await createWlift({ mode: "main" });

  const hatchfile = await fetch("./hatchfile").then(r => r.text());

  const source = `
    import "@hatch:assert" for Expect
    import "@hatch:json"   for JSON

    var data = JSON.parse("{\"name\": \"wlift\", \"version\": 1}")
    Expect.that(data["name"]).toBe("wlift")
    Expect.that(data["version"]).toBe(1)

    System.print("parsed %(data["name"]) v%(data["version"]) ✦")
  `;

  const { output } = await runProject(wlift, source, hatchfile);
  document.getElementById("out").textContent = output;
</script>
<pre id="out"></pre>

# hatchfile — declares the deps `runProject` will install.
name    = "my-app"
version = "0.1.0"
entry   = "main"

[dependencies]
"@hatch:assert" = "0.2.0"
"@hatch:json"   = "0.1.0"

# ~/.config/helix/languages.toml
[[language]]
name             = "wren"
file-types       = ["wren"]
roots            = ["hatchfile"]
language-servers = ["wlift-lsp"]

[language-server.wlift-lsp]
command = "wlift-lsp"

-- init.lua (vim.lsp.config, neovim 0.11+)
vim.filetype.add({
  extension = { wren = "wren" },
})

vim.lsp.config["wlift_lsp"] = {
  cmd          = { "wlift-lsp" },
  filetypes    = { "wren" },
  root_markers = { "hatchfile" },
}
vim.lsp.enable("wlift_lsp")

// ~/.config/zed/settings.json
{
  "languages": {
    "Wren": {
      "language_servers": ["wlift-lsp"]
    }
  },
  "lsp": {
    "wlift-lsp": {
      "binary": { "path": "wlift-lsp" }
    }
  }
}