rusty_v8

A bit worried what will become of https://github.com/denoland/rusty_v8 as it still is the best maintained (?) and featured binding of V8 for rust.

https://github.com/mdesantis/ssr-deno Embed Deno JS runtime into Ruby to perform SSR / render JS views without spawning additional JS processes. It's even 100% working, and Deno just merged a PR which allows me to continue working on it: https://github.com/denoland/rusty_v8/pull/1970#issuecomment-...

Likely similar to something like https://github.com/mlua-rs/mlua - but wanting to execute javascript (instead of lua, and no static libs?) in the context of native rust. The alternative might be https://github.com/denoland/rusty_v8 but without needing C++ V8. (this is the first I'm hearing of Boa)

TS is not interpreted. It compiles to JS, which is interpreted, but TS itself is not. There are no TS interpreters, they all compile to JS behind the scenes. Or does Deno run TS natively? At a glance it looks like even its runtime is written in JS[0]. EDIT: looks like they have bindings for V8[1] so yeah, just a JS interpreter behind the scenes. [0] https://github.com/denoland/deno/tree/main/runtime/js [1] https://github.com/denoland/rusty_v8

I'm building Lagon, an open-source [1] runtime and platform that allows developers to run TypeScript and JavaScript serverless functions at the Edge, close to users. The runtime uses V8 Isolates and is written from scratch using Rust and rusty_v8 [2], Deno's Rust bindings for V8. [1] https://github.com/lagonapp/lagon [2] https://github.com/denoland/rusty_v8

Not to denigrate your work, it's good what you're working on... but I can create JS APIs in Rust with native V8 bindings, too: https://github.com/denoland/rusty_v8/blob/main/examples/proc... After working on a couple codebases that used wasmtime and wasmer heavily, I think if I were to start from scratch I'd just use V8 as my WASM runtime. (And the model I would follow would be to containerize the V8 runtime piece inside its own cgroup, with resource budgets and permission constraints. cgroups accounting beats the limited and inefficient accounting one gets from the various WASM runtime opcode based accounting systems.)

Can Deno be embedded in a larger Rust application? I know I can embed v8 directly https://github.com/denoland/rusty_v8 but I wish I could use other parts of Deno. In particular, I wish I could write a Tokio async program in Rust, and load plugins using deno, and have this work seamlessly edit: actually, https://deno.land/manual@v1.25.0/embedding_deno https://crates.io/crates/deno_core https://docs.rs/deno_core/latest/deno_core/ It doesn't expose tokio so I suppose that it manages its own runtime separate from the executor of the application using it (edit 2: it doesn't, it lets the user bring their own executor. cool!)

Yup, it uses rusty_v8 which are Rust bindings for V8's C++ API - https://github.com/denoland/rusty_v8

I gave it a whirl: > git clone https://github.com/denoland/deno.git denoland/deno > git clone https://github.com/denoland/rusty_v8.git denoland/rusty_v8 > cd denoland/deno > vi Cargo.toml ... [patch.crates-io] rusty_v8 = { path = "../rusty_v8" } ... > cargo build --release ... as expected same failure - good ... Make rusty_v8 build.rs aware of freebsd > vi ../rusty_v8/build.rs ... #[cfg(target_os = "freebsd")] { "freebsd" } ... Have a quick squizz to see where this is used: > rg "platform\(\)" ../rusty_v8 build.rs 157:fn platform() -> &'static str { 180: .join(platform()); Attempt to fix... and bang! It's using the platform() result to call a python script that pulls binaries from here: https://github.com/denoland/ninja_gn_binaries/ And there's no FreeBSD build there. To much yak shav

if anyone at Google wants a fantastic canary-in-the-coal-mine to test Rust support, my absolute #1 most go-to target would be to figure out how you can do a good job supporting Rusty_v8 and Deno in general. denoland@rusty_v8#270 awaits![1] onwards & upward! [1] https://github.com/denoland/rusty_v8/pull/270

The Deno core is easy to embed in Rust (or so they say; I haven’t tried it). https://deno.land/manual/embedding_deno. Note that this is the core and doesn’t include TypeScript support. Also note that the rusty_v8 bindings will by default download a prebuilt version of V8 from GitHub, because otherwise it can be a mild pain to set up and takes a long time to build. See https://github.com/denoland/rusty_v8. I can easily see why one would go with QuickJS: it’ll be much quicker to get going.

The Rust v8 wrapper used in Deno is rusty_v8: https://github.com/denoland/rusty_v8 The whole privileged side (except for v8 itself) is in Rust.