Exploring Programming Language and Runtime Support for RISC-V: From C++ and Rust to JavaScript

The RISC-V architecture, with its open-source, modular design, is gaining traction across various programming languages and ecosystems. Initially adopted for embedded systems and research, RISC-V is now expanding into more mainstream applications. Here’s a look at how languages like C++, Rust, and JavaScript runtimes are supporting RISC-V, as well as future potential across these ecosystems.

1. Established Support: C/C++ and Rust

Several mainstream programming languages and toolchains offer robust support for RISC-V, particularly C/C++ and Rust, which are widely used in systems and embedded programming.

• C/C++:

  • GNU Compiler Collection (GCC): GCC offers comprehensive support for RISC-V, including both an assembler and a compiler, making it one of the primary toolchains for RISC-V development.

  • LLVM/Clang: LLVM and Clang also support RISC-V, enabling developers to work with C++ and other LLVM-compatible languages.

  • GNU Assembler (GAS): As part of the GNU Binutils, GAS includes support for RISC-V, facilitating low-level assembly language programming for more fine-grained control over hardware.

• Rust:

  • Rust has made strides in supporting RISC-V, with official support in its standard library. The Rust compiler (rustc) can target RISC-V, allowing developers to create both system-level and application code for this architecture.

2. Growing Support in Other Languages

Beyond C/C++ and Rust, several other programming languages and runtimes are beginning to embrace RISC-V, albeit in early or experimental stages.

• Go: Go has growing support for RISC-V, especially for embedded and IoT applications, though this is still developing and mainly available in experimental or community-driven builds.

• Python (via MicroPython): MicroPython, a lightweight version of Python for microcontrollers, is compatible with RISC-V on specific boards. While it does not compile directly to assembly, MicroPython provides a viable scripting solution for embedded RISC-V systems.

• Ada (GNAT): The GNAT Ada compiler, which is part of the GCC suite, also includes RISC-V support, allowing Ada developers to target RISC-V for critical systems.

3. JavaScript Ecosystem: Browsers, Node.js, Deno, and Bun

JavaScript support on RISC-V is emerging but less established than C++ or Rust. Efforts are ongoing to bring RISC-V compatibility to JavaScript runtimes and tools, which could make JavaScript more viable on this architecture in the future.

• Web Browsers (Chromium/Firefox): Chromium and Firefox have experimental support for RISC-V, though there is not yet an official browser release optimized for RISC-V. As RISC-V's popularity grows, the need for full browser support on this architecture is expected to increase.

• WebAssembly (Wasm): WebAssembly offers a platform-neutral way to run languages like JavaScript, C, Rust, and TypeScript in the browser. Because WebAssembly operates independently of the underlying CPU architecture, it can potentially run on RISC-V if a WebAssembly runtime is available for it.

• Node.js: Node.js has experimental RISC-V support. Though RISC-V is not officially supported, efforts are underway to port Node.js, especially for IoT applications. The main challenge is optimizing the V8 JavaScript engine, which is heavily tuned for x86 and ARM. Community-driven projects are working to provide compatible Node.js binaries for RISC-V.

• Deno: Deno lacks native RISC-V support but, being based on Rust and the V8 JavaScript engine, could potentially support RISC-V in the future. However, this would require modifications and optimizations in V8.

• Bun: Bun, a newer JavaScript runtime, is built on the JavaScriptCore engine (used in Safari). JavaScriptCore currently lacks RISC-V support, meaning Bun does not yet run on RISC-V. However, with Bun’s growing popularity and interest in expanding RISC-V compatibility, future support is possible.

4. Summary and Future Outlook

While support for RISC-V in JavaScript ecosystems remains in early stages, languages like C/C++ and Rust already offer robust support, positioning RISC-V for more widespread use in systems programming and embedded applications. WebAssembly may serve as an interim solution, enabling languages like JavaScript to run indirectly on RISC-V systems until full native support is developed across major JavaScript engines and runtimes.

As RISC-V adoption continues to grow, both the industry and open-source communities are expected to expand support, particularly in environments like IoT and mobile devices where RISC-V's open architecture is a significant advantage.