Skip to content

Home

Jump to bottom
Akash Kava edited this page Oct 14, 2021 · 13 revisions

Managed JavaScript Runtime

YantraJS is a JavaScript runtime written in .NET Standard. Yantra has two components,

.NET Standard 2.0

Since this is written in .NET Standard 2.0, it runs everywhere except iOS which enforces JIT restrictions. However, there may be a way to interpret IL with mono interpreter but we haven't explored it yet.

Comparison with V8

Running V8 in CLR is expensive, as both V8 and CLR contain same set of features such as garbage collection, threading, and moving objects from to and from V8 hurts performance. And native compilation requirement of V8 puts lot of pressure on maintaining and troubleshooting. So we wanted to create a JavaScript engine which will do everything inside CLR and will try to match performance of other engines. Matching V8 performance is out of scope as C# itself is an higher level language and IL will be JIT compiled at runtime. But we look at Yantra is simple way to integrate with other larger .NET projects. Simplicity in integration overcomes performance drawbacks. Currently Yantra is twice slower compared to V8. However, as time goes, we will certainly try to improve the speed. This is also the primary reason we are trying write lengthy code and avoid runtime inlining as currently there is no macro support in C#.

YantraJS.ExpressionCompiler

Expression compiler is similar to .NET's Linq Expression LambdaCompiler and supports compiling expression to method builder. It is not drop in replacement but the API is quite familiar to Linq Expressions.

YantraJS.Core

YantraJS.Core is a JavaScript engine, which contains Scanner, Parser and Compiler which compiles JavaScript AST to ExpressionCompiler Expressions. That in turn are converted to IL and it can be saved.

ECMAScript Conformance

Currently we are seeing more than 70% conformance to ECMAScript, reaching 100% is little out of scope as it is very huge and Yantra is only one year old. We are focusing on supporting most used JavaScript patterns instead of targeting 100% compliance due to limited development bandwidth.

Features

  1. Compiles JavaScript to .Net Assembly
  2. Strict Mode Only JavaScript*
  3. Arrow functions
  4. Classes
  5. Enhanced object literals
  6. Template strings and tagged templates
  7. Destructuring
  8. let const
  9. Map, Set, WeakMap, WeakSet
  10. Symbols
  11. Subclassable built-ins
  12. Binary and Octal literals
  13. Module support
  14. Null coalesce
  15. Optional property chain identifier?.[], identifier?.(, identifier?.identifier
  16. Rest, Default and Spread Parameters
  17. Generators, iterators, for..of
  18. Async/Await
  19. Optional parameters
  20. Many ES5 + ES6 features
  21. CommonJS Module Support
  22. Easily marshal CLR Object to JavaScript and other way around
  23. CSX Module support

* Most JavaScript today is available in strict mode, we do not feel any need to support non strict mode as modules are strict by default.

Clone this wiki locally