Quickjs

.github/workflows/build-linux.yml

@@ -11,6 +11,10 @@ on:
         required: false
         type: string
         default: g++
+      js-engine:
+        required: false
+        type: string
+        default: ''
       enable-sanitizers:
         required: false
         type: boolean
@@ -39,6 +43,7 @@ jobs:
         run: |
           cmake -B Build/ubuntu -G Ninja \
             -D CMAKE_BUILD_TYPE=RelWithDebInfo \
+            ${{ inputs.js-engine != '' && format('-D NAPI_JAVASCRIPT_ENGINE={0}', inputs.js-engine) || '' }} \
             -D ENABLE_SANITIZERS=${{ inputs.enable-sanitizers && 'ON' || 'OFF' }} \
             -D ENABLE_THREAD_SANITIZER=${{ inputs.enable-thread-sanitizer && 'ON' || 'OFF' }} \
             -D CMAKE_C_COMPILER=${{ inputs.cc }} \

.github/workflows/build-macos.yml

@@ -10,6 +10,10 @@ on:
         required: false
         type: string
         default: macos-latest
+      js-engine:
+        required: false
+        type: string
+        default: ''
       enable-sanitizers:
         required: false
         type: boolean
@@ -32,6 +36,7 @@ jobs:
       - name: Configure CMake
         run: |
           cmake -B Build/macOS -G Xcode \
+            ${{ inputs.js-engine != '' && format('-D NAPI_JAVASCRIPT_ENGINE={0}', inputs.js-engine) || '' }} \
             -D ENABLE_SANITIZERS=${{ inputs.enable-sanitizers && 'ON' || 'OFF' }} \
             -D ENABLE_THREAD_SANITIZER=${{ inputs.enable-thread-sanitizer && 'ON' || 'OFF' }}
 

.github/workflows/ci.yml

@@ -32,6 +32,12 @@ jobs:
       platform: x64
       js-engine: V8
 
+  Win32_x64_QuickJS:
+    uses: ./.github/workflows/build-win32.yml
+    with:
+      platform: x64
+      js-engine: QuickJS
+
   Win32_x64_Hermes:
     uses: ./.github/workflows/build-win32.yml
     with:
@@ -74,6 +80,11 @@ jobs:
     with:
       js-engine: V8
 
+  Android_QuickJS:
+    uses: ./.github/workflows/build-android.yml
+    with:
+      js-engine: QuickJS
+
   Android_Hermes:
     uses: ./.github/workflows/build-android.yml
     with:
@@ -101,6 +112,13 @@ jobs:
       runs-on: macos-26
       enable-thread-sanitizer: true
 
+  macOS_Xcode264_QuickJS:
+    uses: ./.github/workflows/build-macos.yml
+    with:
+      xcode-version: '26.4'
+      runs-on: macos-26
+      js-engine: QuickJS
+
   # ── iOS ───────────────────────────────────────────────────────
   iOS_Xcode264:
     uses: ./.github/workflows/build-ios.yml
@@ -119,6 +137,11 @@ jobs:
       cc: clang
       cxx: clang++
 
+  Ubuntu_QuickJS:
+    uses: ./.github/workflows/build-linux.yml
+    with:
+      js-engine: QuickJS
+
   Ubuntu_Sanitizers_clang:
     uses: ./.github/workflows/build-linux.yml
     with:

CMakeLists.txt

@@ -51,6 +51,11 @@ FetchContent_Declare(UrlLib
     GIT_REPOSITORY https://github.com/BabylonJS/UrlLib.git
     GIT_TAG 74985214bd4f83a4906b2c62134ac2f9ab89e1ae
     EXCLUDE_FROM_ALL)
+FetchContent_Declare(quickjs-ng
+    GIT_REPOSITORY https://github.com/quickjs-ng/quickjs.git
+    GIT_TAG 93d3f7df465027f487ed37e175a0bc3012fee79e
+    EXCLUDE_FROM_ALL)
+
 # --------------------------------------------------
 
 FetchContent_MakeAvailable(CMakeExtensions)
@@ -165,6 +170,11 @@ if(BABYLON_DEBUG_TRACE)
     add_definitions(-DBABYLON_DEBUG_TRACE)
 endif()
 
+if(NAPI_JAVASCRIPT_ENGINE STREQUAL "QuickJS")
+    option(QJS_BUILD_LIBC "Build QuickJS with libc support." ON)
+    FetchContent_MakeAvailable_With_Message(quickjs-ng)
+endif()
+
 if(NAPI_JAVASCRIPT_ENGINE STREQUAL "Hermes")
     # Hermes is currently an experimental engine for JsRuntimeHost and is not
     # supported on Apple platforms (iOS or macOS).  Bail out early with a

Core/AppRuntime/CMakeLists.txt

@@ -52,6 +52,8 @@ if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" AND JSRUNTIMEHOST_CORE_APPRUNTIME_V8_INS
         PRIVATE v8inspector)
 
     set_property(TARGET v8inspector PROPERTY FOLDER Dependencies)
+elseif(NAPI_JAVASCRIPT_ENGINE STREQUAL "QuickJS")
+    target_link_libraries(AppRuntime PRIVATE qjs)
 endif()
 
 set_property(TARGET AppRuntime PROPERTY FOLDER Core)

Core/AppRuntime/Include/Babylon/AppRuntime.h

@@ -67,13 +67,13 @@ namespace Babylon
         // extra logic around the invocation of a dispatched callback.
         void Execute(Dispatchable<void()> callback);
 
-        // Engine-specific hook called from Dispatch immediately after a user
-        // callback completes.  Most engines auto-drain microtasks at scope
-        // exit, so the implementation is a no-op for Chakra/V8/JSC/JSI.
-        // Hermes does NOT auto-drain; its implementation calls
-        // `Napi::DrainJobs(env)` so Promise continuations and queueMicrotask
-        // callbacks scheduled during the user callback actually run before
-        // the next top-level dispatch.
+        // Engine-specific hook called from Dispatch immediately after each user
+        // callback completes. Its job is to drain the engine's microtask/job
+        // queue (Promise continuations, queueMicrotask callbacks, etc.) so they
+        // run before the next top-level dispatch. Most engines auto-drain at
+        // scope exit, so the implementation is a no-op for Chakra/V8/JSC/JSI.
+        // Hermes and QuickJS do NOT auto-drain: their implementations pump the
+        // queue explicitly (Napi::DrainJobs / JS_ExecutePendingJob).
         void DrainMicrotasks(Napi::Env env);
 
         Options m_options;

Core/AppRuntime/Source/AppRuntime_QuickJS.cpp

@@ -0,0 +1,67 @@
+#include "AppRuntime.h"
+#include <napi/env.h>
+
+#ifdef _WIN32
+#pragma warning(push)
+// cast from int64 to int32
+#pragma warning(disable : 4244)
+#endif
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
+#include <quickjs.h>
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+#ifdef _WIN32
+#pragma warning(pop)
+#endif
+
+namespace Babylon
+{
+    void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/)
+    {
+        // Create the runtime.
+        JSRuntime* runtime = JS_NewRuntime();
+        if (!runtime)
+        {
+            throw std::runtime_error{"Failed to create QuickJS runtime"};
+        }
+
+        // Create the context.
+        JSContext* context = JS_NewContext(runtime);
+        if (!context)
+        {
+            JS_FreeRuntime(runtime);
+            throw std::runtime_error{"Failed to create QuickJS context"};
+        }
+
+        // Use the context within a scope.
+        {
+            Napi::Env env = Napi::Attach(context);
+
+            Run(env);
+
+            Napi::Detach(env);
+        }
+
+        // Destroy the context and runtime.
+        JS_FreeContext(context);
+        JS_FreeRuntime(runtime);
+    }
+
+    void AppRuntime::DrainMicrotasks(Napi::Env env)
+    {
+        // QuickJS does not auto-drain its job queue. Promise continuations,
+        // queueMicrotask callbacks, etc. are queued as "pending jobs" and only
+        // run when explicitly pumped. We drain them here, after each user
+        // callback, so async code observes the same "between turns" semantics
+        // it gets on the auto-draining engines (V8/Chakra/JSC).
+        JSRuntime* runtime = JS_GetRuntime(Napi::GetContext(env));
+        JSContext* pending_ctx;
+        while (JS_ExecutePendingJob(runtime, &pending_ctx) > 0)
+        {
+        }
+    }
+}

Core/Node-API/CMakeLists.txt

@@ -47,7 +47,13 @@ if(NAPI_BUILD_ABI)
         endfunction()
     endif()
 
-    if(NAPI_JAVASCRIPT_ENGINE STREQUAL "Chakra")
+    if(NAPI_JAVASCRIPT_ENGINE STREQUAL "QuickJS")
+        set(SOURCES ${SOURCES}
+            "Source/env_quickjs.cc"
+            "Source/js_native_api_quickjs.cc"
+            "Source/js_native_api_quickjs.h")
+        set(LINK_LIBRARIES ${LINK_LIBRARIES} PUBLIC qjs)
+    elseif(NAPI_JAVASCRIPT_ENGINE STREQUAL "Chakra")
         set(SOURCES ${SOURCES}
             "Source/env_chakra.cc"
             "Source/js_native_api_chakra.cc"

Core/Node-API/Include/Engine/QuickJS/napi/env.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <napi/napi.h>
+struct JSContext;
+
+namespace Napi
+{
+  Napi::Env Attach(JSContext* context);
+
+  void Detach(Napi::Env);
+
+  Napi::Value Eval(Napi::Env env, const char* source, const char* sourceUrl);
+
+  JSContext* GetContext(Napi::Env);
+}

Core/Node-API/Source/env_quickjs.cc

@@ -0,0 +1,145 @@
+#include <napi/env.h>
+#include "js_native_api_quickjs.h"
+#include <stdexcept>
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
+#include <quickjs.h>
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+namespace Napi
+{
+    Env Attach(JSContext* context)
+    {
+        napi_env env_ptr{new napi_env__};
+        env_ptr->context = context;
+        env_ptr->current_context = env_ptr->context;
+
+        // Cache Object.prototype.hasOwnProperty for napi_has_own_property's
+        // fast path. These lookups are fundamental to any valid context, so a
+        // failure here signals a broken context: throw rather than silently
+        // leaving has_own_property_function undefined (matching how the other
+        // engines fail Attach loudly).
+        JSValue global = JS_GetGlobalObject(context);
+        JSValue object = JS_GetPropertyStr(context, global, "Object");
+        JS_FreeValue(context, global);
+        if (JS_IsException(object) || !JS_IsObject(object))
+        {
+            JS_FreeValue(context, object);
+            delete env_ptr;
+            throw std::runtime_error{"Napi::Attach: failed to resolve the global 'Object' constructor"};
+        }
+
+        // Use the constructor's "prototype" property to get Object.prototype.
+        // JS_GetPrototype(object) would return the Object *constructor's*
+        // [[Prototype]] (Function.prototype), from which hasOwnProperty is only
+        // reachable by inheritance - correct by luck, but not by intent.
+        JSValue prototype = JS_GetPropertyStr(context, object, "prototype");
+        JS_FreeValue(context, object);
+        if (JS_IsException(prototype) || !JS_IsObject(prototype))
+        {
+            JS_FreeValue(context, prototype);
+            delete env_ptr;
+            throw std::runtime_error{"Napi::Attach: failed to resolve Object.prototype"};
+        }
+
+        JSValue hasOwnProperty = JS_GetPropertyStr(context, prototype, "hasOwnProperty");
+        JS_FreeValue(context, prototype);
+        if (JS_IsException(hasOwnProperty) || !JS_IsFunction(context, hasOwnProperty))
+        {
+            JS_FreeValue(context, hasOwnProperty);
+            delete env_ptr;
+            throw std::runtime_error{"Napi::Attach: failed to resolve Object.prototype.hasOwnProperty"};
+        }
+
+        env_ptr->has_own_property_function = hasOwnProperty;
+
+        return {env_ptr};
+    }
+
+    void Detach(Env env)
+    {
+        napi_env env_ptr{env};
+        if (env_ptr)
+        {
+            // Release every strong napi_ref still outstanding. This mirrors
+            // the V8 impl (napi_env__::DeleteMe) and is essential on QuickJS:
+            // any surviving strong ref pins a JS value from outside the GC
+            // graph, which prevents the teardown cascade in JS_FreeContext
+            // from running and triggers list_empty(gc_obj_list) assert in
+            // JS_FreeRuntime.
+            //
+            // Freeing a value can synchronously run a napi_wrap finalizer
+            // whose C++ destructor releases *other* embedded napi_refs (e.g.
+            // an AbortController destroying its AbortSignal ObjectReference).
+            // Those nested napi_delete_reference calls must not perform a real
+            // JS_FreeValue - otherwise a value can be freed twice - and must
+            // not mutate refs_list while we iterate it. So we first neutralize
+            // every ref (count/value zeroed, list cleared) and only then free
+            // the snapshotted values. Any finalizer-driven
+            // napi_delete_reference then sees count == 0 and is a safe no-op.
+            std::vector<JSValue> strongValues;
+            strongValues.reserve(env_ptr->refs_list.size());
+            for (void* p : env_ptr->refs_list)
+            {
+                auto* info = reinterpret_cast<RefInfo*>(p);
+                if (info->count > 0)
+                {
+                    strongValues.push_back(info->value);
+                }
+                info->count = 0;
+                info->value = JS_UNDEFINED;
+            }
+            env_ptr->refs_list.clear();
+            env_ptr->detached = true;
+
+            for (JSValue value : strongValues)
+            {
+                JS_FreeValue(env_ptr->context, value);
+            }
+
+            if (!JS_IsUndefined(env_ptr->has_own_property_function))
+            {
+                JS_FreeValue(env_ptr->context, env_ptr->has_own_property_function);
+                env_ptr->has_own_property_function = JS_UNDEFINED;
+            }
+
+            // Free all remaining JSValues in the handle scope stack
+            for (auto& ptr : env_ptr->handle_scope_stack)
+            {
+                JS_FreeValue(env_ptr->context, *ptr);
+            }
+            env_ptr->handle_scope_stack.clear();
+
+            // Run the cycle collector so napi_wrap finalizers (which
+            // destroy C++ wrapper objects and release any embedded
+            // napi_refs) get a chance to execute while the env is still
+            // valid. A second pass picks up anything unpinned by the
+            // first pass's finalizers.
+            JSRuntime* rt = JS_GetRuntime(env_ptr->context);
+            JS_RunGC(rt);
+            JS_RunGC(rt);
+
+            // Drop the initial owner reference taken in Attach. If every
+            // ExternalData finalizer already ran during the GC passes above,
+            // this deletes the env now. If some are deferred to the engine's
+            // JS_FreeContext/JS_FreeRuntime teardown cascade (the common case),
+            // each still holds a count, so the env survives until the last such
+            // finalizer completes and drops the final count - deleting the env
+            // exactly once, after its last use, with no leak.
+            //
+            // NOTE: env_ptr must not be touched after this point; it may have
+            // already been deleted.
+            env_ptr->Unref();
+        }
+    }
+
+    JSContext* GetContext(Env env)
+    {
+        napi_env env_ptr{env};
+        return env_ptr->context;
+    }
+}