Expand description

High-level bindings to quickjs

The rquickjs crate provides safe high-level bindings to the quickjs javascript engine. This crate is heavily inspired by the rlua crate.

The Runtime and Context objects

The main entry point of this library is the Runtime struct. It represents the interperter state and is used to create Context objects. As the quickjs library does not support threading the runtime is locked behind a mutex. Multiple threads cannot run as script or create objects from the same runtime at the same time. The Context object represents a global environment. Contexts of the same runtime can share javascript objects like in browser between frames of the same origin.

Converting Values

This library has multiple traits for converting to and from javascript. The IntoJs trait is used for taking rust values and turning them into javascript values. The FromJs is for converting javascript value to rust. Note that this trait does not automatic coercion but the Coerced can be used to convert the values with coercion.

For values which represent the name of variables or indecies the trait IntoAtom is available to convert values to the represention quickjs requires.

Optional features


This crate can be customized via features. The following features is enabled by default but can be disabled when not needed:

  • classes enables support for ES6 classes. Any user-defined Rust type can be exported to JS as an ES6 class which can be derived and extended by JS.
  • properties enables support for object properties (Object.defineProperty).
  • exports adds an ability to read the module exports.


The following features may be enabled to get an extra functionality:

  • allocator adds support for custom allocators for Runtime. The allocators should implements Allocator trait and can be plugged on Runtime creation via Runtime::new_with_alloc.
  • rust-alloc forces using Rust’s global allocator by default instead of libc’s one.
  • loader adds support for custom ES6 modules resolvers and loaders. The resolvers and loaders should implements Resolver and Loader traits respectively and can be plugged in already existing Runtime before loading modules via Runtime::set_loader. The resolvers and loaders can be easily combined via tuples. When the previous resolver or loader failed the next one will be applied.
  • dyn-load adds support for loadable native modules (so/dll/dylib).
  • array-buffer adds support for ArrayBuffer and TypedArray.
  • futures adds support for async Rust. When enabled the Rust futures can be passed to JS as ES6 Promises and ES6 Promises can be given back as Rust futures.
  • tokio adds integration with tokio async runtime. The method Runtime::spawn_executor can be used with Tokio to spawn async executor.
  • async-std adds integration with async_std runtime. The method Runtime::spawn_executor can be used with AsyncStd to spawn async executor.
  • smol adds integrations with smol async runtime. The method Runtime::spawn_executor can be used with Smol to spawn async executor.
  • macro enables some useful procedural macros which gets Rust/JS interop much easy. An attribute macros can be applied to functions, constants and modules. An derive macros can be used with structs and enums.
  • phf enables using Perfect Hash Function for builtin modules lookup


To gets build faster the numbers of arguments which can be passed to and given by the functions is limited to 6. If you need more arguments you can enabled feature max-args-N where N is number from 7 to 16.

Extra types

This crate has support for conversion of many Rust types like Option, Result, Vec and other collections. In addition an extra types support can be enabled via features:


The bindings is pre-built for the following platforms:

  • i686-unknown-linux-gnu, x86_64-unknown-linux-gnu
  • x86_64-apple-darwin
  • i686-pc-windows-gnu, x86_64-pc-windows-gnu, i686-pc-windows-msvc, x86_64-pc-windows-msvc

To build the crate for unsupported target you must enable bindgen feature.


  • parallel enables multithreading support.

Note that the experimental features which may not works as expected. Use it for your own risk.


QuickJS can be configured to output some info which can help debug. The following features enables that:

  • dump-bytecode
  • dump-gc
  • dump-gc-free
  • dump-free
  • dump-leaks
  • dump-mem
  • dump-objects
  • dump-atoms
  • dump-shapes
  • dump-module-resolve
  • dump-promise
  • dump-read-object


A marker types for intrinsic

Native low-level bindings



The macro to simplify class definition.

The helper macro to impl Loader traits for generic module kind.

Helper macro to provide module init function



The accessor descriptor of a readonly property

Rust representation of a javascript object optimized as an array.


Rust representation of a javascript object of class ArrayBuffer.


The wrapper for async functons


The async_std runtime for spawning executors.

An atom is value representing the name of a variable of an objects and can be created from any javascript value.

The builtin script module loader

The builtin module resolver

The resolver and loader for bundles of compiled modules


The class object interface


The type of identifier of class

The wrapper for values to force coercion


Modules compiling data

The wrapper for constructor function

A single execution context with its own global variables and stack.

Used for building a Context with a specific set of intrinsics

The marker for the module which is created but not loaded yet

Context in use, passed to Context::with.

The marker for the module which is already loaded and evaluated


The async executor future

An iterator over the items exported out a module

An iterator over the items exported out a module

The file module resolver

The property filter

The wrapper for function to convert is into JS

Rust representation of a javascript function.

The idle awaiting future

The marker for the module which is loaded but not evaluated yet

The wrapper for method functions

Javascript module with certain exports and imports

The builtin native module loader

The wrapper for mutable functions

The marker for the module which is created using ModuleDef


The native module loader

The placeholder which treated as null value

Rust representation of a javascript object.

The wrapper for once functions

The wrapper to get optional argument from input

The wrapper for JS values to keep it from GC


Future-aware promise


Wrapper for futures to convert to JS promises


The data descriptor of a property


The helper for QuickJS garbage collector which helps it find internal JS object references.


Key for a registery of a context.

The wrapper the rest arguments from input

Quickjs runtime, entry point of the library.

The allocator which uses Rust global allocator

The marker for the module which is created from text source

The script module loader

Smolsmol and parallel

The smol async runtime for spawning executors.

Rust representation of a javascript string.

Rust representation of a javascript symbol.

The wrapper to get this from input


The tokio async runtime for spawning executors.


Rust representation of a javascript objects of TypedArray classes.

The placeholder which treated as undefined value

The placeholder which treated as uninitialized JS value

Any javascript value


The prototype setting wrapper


Error type of the library.

The type of value



The allocator interface

A helper trait to pass arguments on a function calls.

The trait to wrap rust function to JS directly


The property interface


The ES6 class definition trait

The trait to spawn execution of pending jobs on async runtime

Trait for converting values from atoms.

The Rust’s FromIterator trait to use with Ctx

For converting javascript values to rust values

The module data which contains bytecode


The helper trait to mark internal JS value refs

Trait for converting values to atoms.

For converting rust values to javascript values

The internal trait to add JS builting

The Rust’s Iterator trait extension which works with Ctx


Module loader interface

Module definition trait

A trait for using multiple contexts at the same time.

The helper trait to define objects

The trait to help break lifetime rules when JS objects leaves current context via Persistent wrapper.


Module resolver interface

Type Definitions

The raw module load function (js_module_init)


Raw memory pointer

Result type used throught the library.

Attribute Macros

An attribute to generate bindings easy

An attribute to convert scripts modules into builtins

Derive Macros

A macro to derive FromJs for an arbitrary structured types

A macro to derive HasRefs

A macro to derive IntoJs for an arbitrary structured types

A macro to derive IntoJs for an arbitrary structured types when it used by reference