QuickJS

QuickJS
Name	QuickJS
Developer	Fabrice Bellard
Latest release	2024-01 (example)
Operating system	Linux, FreeBSD, NetBSD, OpenBSD, Windows, macOS
Platform	x86-64, ARM, RISC-V
Genre	JavaScript engine
License	MIT License

QuickJS

QuickJS is a compact, embeddable JavaScript engine created to implement the ECMAScript 2020 specification with a focus on small code size and efficient memory use. It is notable for providing full support for modern JavaScript features such as Async/await, Proxy objects, and BigInt while remaining suitable for use in constrained environments like embedded systems and single-board computers such as the Raspberry Pi. The project originates from the work of a prominent systems programmer and author known for contributions to virtualization and compiler tooling.

Overview

QuickJS targets scenarios where lightweight, standards-compliant scripting is required alongside interoperability with native code. It aims to balance conformance to the ECMAScript Language Specification with minimal dependencies, making it viable for integration in projects ranging from LibreOffice plugins to appliance firmware. The engine exposes a C API for embedding into applications developed by teams at institutions like Google, Mozilla, Intel, and smaller vendors in the open-source ecosystem. Community contributions and ports have extended support to architectures championed by organizations such as ARM Limited and companies producing RISC-V silicon.

Design and Implementation

The engine is implemented in portable C99 and uses a bytecode interpreter combined with a minimal parser to execute scripts. Its implementation strategy emphasizes simplicity: a compact parser, a register-based bytecode format, and a small runtime that includes a garbage collector inspired by designs discussed at conferences like USENIX Annual Technical Conference and ACM SIGPLAN workshops. The architecture allows embedding into applications maintained by projects like Node.js alternatives and integrations used by Mozilla-affiliated efforts. The codebase interacts with standard toolchains involving GCC, Clang, and build systems such as CMake and GNU Make.

Language Features

QuickJS implements a wide set of modern ECMAScript features including ES6, ES2016, and later extensions like BigInt, Async functions, Generators, Proxy objects, and the Intl internationalization API. It provides a module loader supporting both CommonJS-ish patterns and ECMAScript modules. The engine exposes an embedding API that lets host applications create native bindings to functions and objects used by systems from Red Hat or embedded vendors. Support for WeakRef and FinalizationRegistry types aligns the runtime with features discussed in proposals tracked by standards bodies such as TC39.

Performance and Benchmarks

Benchmarks for the engine typically emphasize startup time, memory footprint, and throughput for microbenchmarks derived from suites maintained by groups like SPEC and js-framework-benchmark authors. In constrained-memory tests run on single-board computers from manufacturers like Broadcom and Allwinner, it frequently outperforms larger engines in terms of binary size and resident set size. For compute-bound workloads, engines developed by companies such as Google and Apple can present higher raw throughput due to JIT compilation strategies implemented in products like V8 and JavaScriptCore, but QuickJS’s interpreter plus optional lightweight trampolines delivers competitive performance in many real-world scripting tasks.

Tooling and Ecosystem

A modest ecosystem of tools and bindings surrounds the engine: build integration with Autotools and CMake, language bindings for projects produced by contributors from Debian and Fedora, and packaging maintained by distributions such as Arch Linux, OpenWrt, and Yocto Project layers. Community repositories provide compiled runtimes for architectures promoted by RISC-V International and cross-compilation support using toolchains like musl-based toolchains. Tooling for debugging and profiling connects with utilities like gdb and static analyzers used in projects by organizations such as LLVM and Google.

Adoption and Use Cases

Adopters include developers building scripting layers for embedded devices from vendors like Espressif and appliance makers using firmware stacks influenced by OpenWrt. Desktop applications seeking an alternative scripting host to engines used by Chromium or Firefox integrate the engine to provide user extensions and macros. Academic projects at institutions such as MIT and ETH Zurich use it for research on language runtimes, while open-source projects like FFmpeg-related frontends and LibreOffice-adjacent tooling embed it for extensibility. Its small footprint also attracts use in Internet of Things projects promoted by organizations like Eclipse Foundation.

Licensing and Development History

The engine is distributed under a permissive license, facilitating inclusion in proprietary and open-source products distributed by corporations like Siemens and community-driven projects hosted on platforms such as GitHub. Its maintenance has been driven primarily by its original author with patches and ports contributed by engineers affiliated with companies and distributions like Debian, Fedora, Collabora, and independent contractors. Development discussions and standards alignment have referenced meetings and proposals in venues such as ECMA International and conferences like FOSDEM and Embedded Linux Conference.

Category:JavaScript engines