Porting the V8 JavaScript Engine to HarmonyOS: Background, Architecture, Tool Selection, and Cross‑Compilation Process

The Roma framework, a dynamic cross‑platform solution supporting iOS, Android and Web, requires a JavaScript engine on HarmonyOS because the platform lacks a built‑in JS runtime. V8, Google’s open‑source engine, is chosen for its widespread use in browsers, Node.js, Electron and other environments.

V8 Engine Architecture

V8 executes JavaScript by parsing source code into an Abstract Syntax Tree (AST), generating bytecode with the Ignition interpreter, and then JIT‑compiling hot functions with TurboFan. The engine also includes the Orinoco garbage collector, which uses concurrent marking, incremental collection and other strategies to manage memory efficiently.

Key components are:

Parser – lexical and syntactic analysis producing the AST.

Ignition – converts the AST to bytecode and interprets it.

TurboFan – optimizes frequently executed bytecode into machine code.

Orinoco – performs garbage collection.

Sample code snippets illustrate how V8’s built‑ins are generated and executed, e.g., the IGNITION_HANDLER(Ldar, InterpreterAssembler) implementation and the C++ macro‑based code that builds built‑ins during snapshot creation.

Cross‑Compilation Toolchain

To build V8 for HarmonyOS (arm64‑v8a) from a host machine (macOS M1), the process uses:

GN + Ninja for the original V8 build.

CMake + Ninja (or Make) for the HarmonyOS build, converting GN scripts to CMake.

A tool‑chain file that sets CMAKE_C_COMPILER , CMAKE_CXX_COMPILER and CMAKE_LINKER for the target architecture.

Typical commands are:

mkdir build && cd build
cmake -G Ninja ..
ninja

and for the target platform:

cmake -DOHOS_ARCH=arm64-v8a -DCMAKE_TOOLCHAIN_FILE=/path/to/ohos.toolchain.cmake -G Ninja ..
ninja

During the build, host‑compiled tools ( bytecode_builtins_list_generator , torque , mksnapshot ) are copied to /usr/local/bin so they can be invoked when generating target‑specific built‑ins and snapshots.

Built‑ins and Snapshots

V8’s built‑ins are created by the mksnapshot tool, which runs the engine in a simulator for the target CPU (e.g., arm64) and dumps the resulting machine code into embedded.S . Snapshots serialize heap objects, compiled bytecode and global state, allowing fast startup on the target device.

Integrating V8 into a HarmonyOS Native Project

After cross‑compiling, the generated static library ( libv8_snapshot.a ) and header files are added to a native C++ module. A CMakeLists.txt file sets the C++17 standard, links the V8 library, and defines NAPI methods that can be called from ArkTS/ETS code. The article shows a simple demo where a C++ function is exported, invoked from JavaScript, and the result displayed in the HarmonyOS UI.

Future Directions

The author discusses trends such as compiling TypeScript directly to bytecode, removing dynamic‑language overhead, and leveraging V8‑based engines like Hermes or HarmonyOS’s Panda for IoT devices, emphasizing the trade‑off between strict typing and performance.