Yavashark blog · October 28, 2026
\nToday I am announcing Yavashark, a small embeddable and easily extendable JavaScript engine that passes 82% of test262 with support for Temporal, Intl and React/TS.
\nI’ve built on it every single day since March 17, 2024 as a side project. I’m still the only contributor, but I am accepting contributions! So far I’ve made over 4200 commits to the engine repo.
\nDespite that number, the engine is still far from complete, but it can already run many JavaScript programs.
\nFirst of all, feel free to try it out on the playground directly at https://yavashark.dev/ !
\nToday the engine passes around 82% of the test262 test suite and I’m committed to pushing that even higher.
\nAlready implemented are Temporal via Boa’s amazing temporal_rs crate (which is also used in Google’s V8) and Intl via the icu4x crate.\nThere are, however, many other features still missing or only half-implemented.
\nYavashark is currently blazingly fast slow. But factoring in the amount of actual optimizations present, it is quite acceptable in terms of speed!\nThe engine has no hidden classes, inline caches, NaN-boxing, efficient object layout or a fast bytecode. In fact, it mostly uses a tree-walking interpreter plus a bytecode for async/await (but it has many missing features).
Yavashark’s CLI can even already run TypeScript and React with TypeScript, including the full react and react-dom libraries (demos available in the engine repo).
\nExtending Yavashark is very easy. One can just bind Rust functions and methods to JavaScript via a macro, making it really easy to extend the engine with custom capabilities.\nThe engine can be compiled with experimental features which include a TCP and HTTP API, a filesystem and I/O API and some early timer work.\nAll of these are intentionally very small, though I am open to anyone wanting to make them more mature.
\nHere is a small example of the engine’s fs API:
\n// Define `Fs` as an Object\n#[object]\n#[derive(Debug)]\npub struct Fs {}\n\n#[properties_new(raw)]\nimpl Fs {\n fn open(path: &str) -> Res<String> {\n let contents = fs::read_to_string(path) // open and read the contents of that file\n .map_err(|e| Error::new_error(e.to_string()))?; // convert error and propagate as a JS-exception\n\n Ok(contents)\n }\n}After binding the object with some small binding glue to the engine’s global object, you can just do the following in JavaScript:
\nlet script = Fs.open("foo.js")\n\neval(script)More embedding examples can also be found in the engine’s repo in the examples dir and the React demo in the demos dir
\nYavashark will be getting a lot of optimizations in the future, mostly the ones missing from above, but also a new Garbage Collector (GC) which will also be usable for the rest of the Rust ecosystem. Most current Rust GC’s are very simple and single-threaded mark and sweep or cycle-collecting algorithms. A real high-performance GC is still missing.
\nThe GC is planned to be a concurrent moving generational GC with fast memory allocation capabilities.
\nThe new NaN-boxing and optimized object format mentioned above are already in the works and close to finalization.
\nLastly, a new bytecode with inline caches and cheap dispatch will round off the initial performance improvements.
\nFrom these optimizations you should not expect a new V8-level engine, at least not for raw compute performance. In early testing, a prototype was able to consistently outperform V8’s jitless mode in all microbenchmarks and in some even V8 with JIT enabled.
\nTo give you a small sneak peek: across a set of 19 microbenchmarks, the prototype interpreter (with its new GC enabled) is on average about 3.5× faster than V8’s jitless mode, and it beats it in every single one. In a few of them, like exceptions and generators, it even beats V8 with its JIT turned on. Mostely because V8 has to do some extra steps which the Yavashark doesn’t need to.
\nHowever, take all of that with a big grain of salt, since integrating into the real engine might bring many more slowdowns.
\nThese two and a half years have been incredibly fun and I’ve learned so many new things.
\nIn the process of writing the engine I’ve joined Ecma’s TC39 as an Invited Expert! Being under 20 years old, I am probably one of the youngest, if not the youngest, person in TC39.\nDespite my young age, TC39 has been (and still is) a very welcoming community of incredible people!\nThe meetings are always very fun and interesting. I’ve met so many cool and inspiring people, making the meetings easily the most fun weeks of the year!
\nLastly, I’d really appreciate it if you could give the engine repo a star on GitHub.\nIf you like the project, consider supporting me via GitHub Sponsors. With that you are helping a young girl pay her university bills!
\nNow it’s over to you, so I wish you a nice day, night or whatever time you are reading this, and don’t forget to have some fun with the engine!
\nOriginally published at the Yavashark blog.
","headings":[{"level":2,"text":"Present Status","id":"present-status"},{"level":2,"text":"Roadmap","id":"roadmap"},{"level":2,"text":"A Personal Note","id":"a-personal-note"}]}}