4 ms·
V8 Release v9.6
- amelius 5y agoI'm waiting for a Rust version, mainly because of its stronger security but also because of the integration. Edit: Of the JS engine which is now in C++; not sarcasm.
- coldtea 5y ago>Of the JS engine which is now in C++; not sarcasm. Not gonna happen.
- ddoolin 5y agoRust version of what? V8, JS engine?
- scoopertrooper 5y agoEver heard of a little project called Firefox? I hear they've been dipping their toes a little into the space of late.
- zarzavat 5y agoV8 compiles JavaScript into machine code, which is then executed. It is an inherently unsafe business to be in, while Rust might make it more safe it will never make it safe. Better to put that effort into better sandboxing, as that is the weakest link.
- saagarjha 5y agoJust because the Rust code cannot be made "fully" safe doesn't mean it should be ruled out and replaced with sandboxing. For one, they can both be worked on, but it's also important to note that Rust can provide useful safety guarantees that are actually useful to have. For example, in C++ a linear overflow may end up leading to the ability to spray arbitrary shellcode, but in Rust you may be able to guarantee that any out-of-bounds accesses cannot be used to do this.
- pjmlp 5y agoIt would be so nice to have something like -fsafe instead of a myriad of mitigations, where the right defaults get enabled, but it will never happen. By the way, the upcoming ARM conference has sessions regarding MTE.
- pjmlp 5y agoYou can keep waiting, given that Google prefers to somehow mitigate C++ flaws than going through Chrome's version of Servo. https://security.googleblog.com/2021/09/an-update-on-memory-safety-in-chrome.html https://security.googleblog.com/2021/09/an-update-on-memory-... > Even if we started writing new large components in Rust tomorrow, we’d be unlikely to eliminate a significant proportion of security vulnerabilities for many years. And can we make the language boundary clean enough that we can write parts of existing components in Rust? We don’t know yet. We’ve started to land limited, non-user-facing Rust experiments in the Chromium source code tree, but we’re not yet using it in production versions of Chrome - we remain in an experimental phase.
- Indy9000 5y agoSo it's.... V9 now? . . . I'll get my coat
- More-nitors 5y agoyes Cult of V8 is no more...
- ksec 5y agoIt is either a more performant engine which will be V12, or more efficient which will be V6.
- themihai 5y ago>> The Reference Types proposal, shipped in V8 v9.6, allows using external references from JavaScript opaquely in WebAssembly modules. Does this mean we now have direct DOM access from WASM and GC support?
- paavohtl 5y agoNo, not yet. This is just the first step, which allows passing handles to JS/DOM objects to WASM, but they are opaque to WASM and they cannot yet be interacted with in any other way than passing them back to JS.
- flohofwoe 5y agoIt just means that the Javascript API shim between WASM and web APIs doesn't need to translate between numeric handles and Javascript object references anymore, making those shims much smaller, and maybe in some cases the shims can disappear completely. (here's an example of such a shim for WebGPU in the Emscripten SDK: https://github.com/emscripten-core/emscripten/blob/main/src/library_webgpu.js https://github.com/emscripten-core/emscripten/blob/main/src/...)
- trzeci 5y agoThis is something that I'm worry about: It forces Emscripten builds to be created differently in the way the build artifacts will be compatible only with that version of V8 - in practice it means a dead feature that looks nice, but we can't use for a long long time.
- gmitscha 5y ago>> The Reference Types proposal, shipped in V8 v9.6, allows using external references from JavaScript opaquely in WebAssembly modules. This is a major step for WebAssembly which I've waited for a long time! Note that Chrome was the last major browser not supporting reference types, so soon we'll be able to use this on real websites: https://webassembly.org/roadmap/ https://webassembly.org/roadmap/ The main contribution is that now arbitrary values can be passed between JS and Wasm modules. These will show up on the Wasm side as opaque `externref` types. This allows (arbitrarily powerful) Wasm modules that only import JavaScript glue code instead of having to wrap their exports with JS functions. "Modules that import the functionality they need" is, IMO, a much saner model for creating an ecosystem of modules than "modules which are wrapped with functions specific to the functionality they need". I think this will lead to * more transparent code (= closer correspondence between the code which is compiled to Wasm and the thing that actually runs in your browser) * a standard interface between functions across the ecosystem => much more potential to just import and use Wasm modules written in other languages * an easier way to ship only the minimal amount of JS glue code you need