It optionally supports mathematical extensions such as big decimal floating point numbers (BigDecimal), big binary floating point numbers (BigFloat) and operator overloading.
- Small and easily embeddable: just a few C files, no external dependency, 210 KiB of x86 code for a simple hello world program.
- Fast interpreter with very low startup time: runs the 75000 tests of the ECMAScript Test Suite in about 100 seconds on a single core of a desktop PC. The complete life cycle of a runtime instance completes in less than 300 microseconds.
- Almost complete ES2020 support including modules, asynchronous generators and full Annex B support (legacy web compatibility).
- Passes nearly 100% of the ECMAScript Test Suite tests when selecting the ES2020 features. A summary is available at Test262 Report.
- Garbage collection using reference counting (to reduce memory usage and have deterministic behavior) with cycle removal.
- Mathematical extensions: BigDecimal, BigFloat, operator overloading, bigint mode, math mode.
- Small built-in standard library with C library wrappers.
For information about supported releases, see the release schedule.
- Secure by default
- Native support for TypeScript and JSX
- Testing, linting, formatting, and more out of the box
- High performance async I/O with Rust and Tokio
- Backwards compatible with Node.js and npm
- 100% Spec Compliance
- Ease of modification
- Speed at the expense of any of the goals This project is bound by a Code of Conduct.
Join us in
Duktape is easy to integrate into a C/C++ project: add
duk_config.hto your build, and use the Duktape API to call ECMAScript functions from C code and vice versa.
- Embeddable, portable, compact: can run on platforms with 160kB flash and 64kB RAM
- ECMAScript E5/E5.1, with some semantics updated from ES2015+
- Partial support for ECMAScript 2015 (E6) and ECMAScript 2016 (E7), see Post-ES5 feature status and kangax/compat-table
- ES2015 TypedArray and Node.js Buffer bindings
- CBOR bindings
- Encoding API bindings based on the WHATWG Encoding Living Standard
- Built-in debugger
- Built-in regular expression engine
- Built-in Unicode support
- Minimal, retargetable platform dependencies
- Combined reference counting and mark-and-sweep garbage collection with finalization
- Property virtualization using a subset of ECMAScript ES2015 Proxy object
- Bytecode dump/load for caching compiled functions
- Distributable includes an optional logging framework, CommonJS-based module loading implementations, etc
- Liberal license (MIT)
MuJS was designed with a focus on small size, correctness, and simplicity. It is written in portable C and implements ECMAScript as specified by ECMA-262. The interface for binding with native code is designed to be as simple as possible to use, and is very similar to Lua. There is no need to interact with byzantine C++ template mechanisms, or worry about marking and unmarking garbage collection roots, or wrestle with obscure build systems.
MuJS is developed and maintained by Artifex Software. It was originally developed for use with the MuPDF viewer, but is designed to be useful as an independent component.
The primary meeting place for the MuJS community is the #mupdf Discord channel.
MuJS is free open source software distributed under the ISC license.
Nashorn engine is an open source implementation of the ECMAScript Edition 5.1 Language Specification. It also implements many new features introduced in ECMAScript 6 including template strings;
const, and block scope; iterators and
WeakSetdata types; symbols; and binary and octal literals. It is written in Java and runs on the Java Virtual Machine.
Nashorn used to be part of the JDK until Java 14. This project provides a standalone version of Nashorn suitable for use with Java 11 and later.
Nashorn is free software, licensed under GPL v2 with the Classpath exception, just like the JDK.
(originally on Google Code)
TinyJS is not designed to be fast or full-featured. However it is great for scripting simple behaviour, or loading & saving settings.
Currently TinyJS supports:
- Variables, Arrays, Structures
- JSON parsing and output
- Objects with Inheritance (not fully implemented) Please see CodeExamples for examples of code that works...
For a list of known issues, please see the comments at the top of the TinyJS.cpp file, as well as the GitHub issues
Elk features include:
- Cross platform. Works anywhere from 8-bit microcontrollers to 64-bit servers
- Zero dependencies. Builds cleanly by ISO C or ISO C++ compilers
- Easy to embed: just
elk.hto your source tree
- Small and simple embedding API
- Does not use malloc. Operates with a given memory buffer only
- Small footprint: about 20KB on flash/disk, about 100 bytes RAM for core VM
- No bytecode. Interprets JS code directly
Elk approach is different from other scripting environments like micropython, which provide a complete JS API for everything. Elk is completely bare, it does not even have a standard library. All required functionality is supposed to be imported from C/C++ firmware, and JS code simply orchestrates things. That leaves Elk very minimal and tunable.
Below is a blinky demonstration on a classic Arduino Nano board which has 2K RAM and 30K flash (see full sketch):
17 Nov 2023
- URL imports.
- useful Web APIs.
- compiles TypeScript out of the box.
- compiling to native distributable binaries.
You might use it:
- As an application server, to self-host applications designed for Cloudflare Workers.
- As a development tool, to develop and test such code locally.
- As a programmable HTTP proxy (forward or reverse), to efficiently intercept, modify, and route network requests
Developed completely for fun and experimentation.
- Any valid mJS code is a valid ES6 code.
- Any valid ES6 code is not necessarily a valid mJS code.
- Only few kilobytes of RAM available to the engine (<64 KB RAM)
- Constrained ROM space for the code of the engine (<200 KB ROM)
J2V8 is a set of Java bindings for V8. J2V8 focuses on performance and tight integration with V8. It also takes a 'primitive first' approach, meaning that if a value can be accessed as a primitive, then it should be. This forces a more static type system between the JS and Java code, but it also improves the performance since intermediate Objects are not created.
BESEN is an acronym for "B ero's E cma S cript E ngine", and it is a complete ECMAScript Fifth Edition Implemention in Object Pascal, which is compilable with Delphi >=7 and Free Pascal >= 2.5.1 (maybe also 2.4.1).
BESEN is licensed under the LGPL v2.1 with static-linking-exception.
- Complete implementation of the ECMAScript Fifth Edition standard
- Own bytecode-based ECMA262-complaint Regular Expression Engine
- Incremental praise/exact mark-and-sweep garbage collector
- Unicode UTF8/UCS2/UTF16/UCS4/UTF32 support (on ECMAScript level, UCS2/UTF16)
- Bytecode compiler
- Call-Subroutine-Threaded Register-based virtual machine
- Context-Threaded 32-bit x86 and 64-bit x64/AMD64 Just-in-Time Compiler (a ARMv7 EABI JIT for ARM CPUs with VFPv3 instruction set is planned)
- Constant folding
- Dead code elimination
- Abstract-Syntax-Tree based optimizations
- Type inference (both exact and speculative)
- Polymorphic Inline Cache based on object structure and property key IDs
- Perfomance optimized hash maps
- Self balanced trees (for example to sort on-the-fly linked list items of hash maps for very fast enumeration of array objects)
- Easy native Object Pascal class integration (properties per RTTI and published methods per by-hand-parsing of the native virtual method table)