Rust is Eating JavaScript

Today’s Issue: Ubuntu Is Moving to Rust, Targeting Foundational Software in Rust, and Rust is the New C

Ferris the crab mascot - Image courtesy of tweedegolf

Hello Rustaceans! 🦀

Welcome to another edition of Rust Bytes newsletter.

In this issue, we’ll discuss how Rust is silently transforming the JavaScript tooling ecosystem, share with you a useful Rust tip, spotlight an amazing Rust project, and share some incredible links of the week.

Here’s issue 58 for you!

THE MAIN THING

Rust is Eating JavaScript

Last week, Anders Hejlsberg, creator of TypeScript, made a huge announcement about moving TypeScript's core tooling to Go—Rust’s close cousin in the programming world.

I know you’re side-eyeing this and thinking, 'Rust was right there, so why not?’ As your dedicated Rust evangelist, I will discuss with you how Rust has been quietly transforming the JavaScript ecosystem.

JavaScript tooling, which is the backbone of modern web development, is showing its age. Tools like Webpack and Babel, while revolutionary in their time, are plagued by sluggish build times and single-threaded bottlenecks that choke performance as projects scale.

These limitations rise from JavaScript’s design: interpreted, and single-threaded, which is not-suited for the heavy lifting of parsing, bundling, and transpiling massive codebases.

Rust’s promise of speed, memory safety guarantees, and seamless integration with WebAssembly (WASM) has brought new life into the JavaScript scene, offering benefits that developers can’t ignore.

Rust’s growing fame has sparked a 'rewritten in Rust' trend, spreading across the JavaScript ecosystem. Instead of facing resistance, we’ve seen many JavaScript tools being rewritten in Rust to take advantage of its performance benefits. And as you would guess, we are noticing a toolchain revival where performance isn’t a luxury it’s the new standard.

Here’s a list of JavaScript tools that have been partly or wholly rewritten in Rust, proving that this isn’t just hype.

The Big Players

• Deno. A modern runtime for JavaScript and TypeScript, Deno was built from the ground up in Rust by Ryan Dahl—the original creator of Node.js.

• Speedy Web Compiler (SWC). An extensible Rust-based platform for the next generation of fast developer tools. It's used by tools like Next.js, Parcel, and Deno, as well as companies like Vercel, ByteDance, Tencent, and Shopify.

• Rspack. A high performance JavaScript bundler written in Rust. It offers strong compatibility with the webpack ecosystem, allowing for seamless replacement of webpack, and provides lightning fast build speeds.

• Rolldown. A JavaScript/TypeScript bundler written in Rust intended to serve as the future bundler used in Vite. It provides Rollup-compatible APIs and plugin interface, but will be more similar to esbuild in scope.

• Turborepo. An incremental bundler optimized for JavaScript and TypeScript, written in Rust, and built into Next.js. You can use Turborepo with both the Pages and App Router for a much faster local development experience.

• Oxc (The Oxidation Compiler). This ambitious project is a suite of high-performance tools for JavaScript and TypeScript. Oxc includes a parser, linter, formatter, transformer, minifier, and resolver, offering a modular, all-in-one solution that’s as fast as it is versatile.Repository files navigation

• Neon. Rust bindings for writing safe and fast native Node.js modules.

New Tools

Beyond the big names, a fresh set of Rust-based tools is emerging, each with innovative solutions to JavaScript developers.

• Biome. A fast formatter for JavaScript, TypeScript, JSX, TSX, JSON, CSS and GraphQL that scores 97% compatibility with Prettier, saving CI and developer time.

• Lightning CSS. An extremely fast CSS parser, transformer, and minifier. It works seamlessly with Parcel or as a standalone library, CLI, or plugin for other tools. It’s a game-changer for anyone tired of sluggish CSS processing.

• Boa. An embeddable and experimental JavaScript engine.

• Parcel. A zero configuration build tool for the web.

• Ezno. A fast and correct TypeScript type checker and compiler with additional experiments

• Nova. A JavaScript (ECMAScript) and WebAssembly engine written in Rust and following data-oriented design principles.

• Canvas. High performance skia binding to Node.js. Zero system dependencies and pure npm packages without any postinstall scripts or node-gyp.

• Volta. The Hassle-Free JavaScript Tool Manager.

JavaScript tooling written in Rust are catching on fast. Big projects like Next.js use SWC for speedy builds, and Vite is eyeing Rolldown for the same reason.

Developers love the performance boost. But not everyone’s sold. Some JavaScript fans want tools to stay in JavaScript because it’s easier to tweak and matches the ecosystem.

Others resist because learning Rust feels hard and they worry about messing up their current setups. Still, more and more are switching as Rust proves its worth.

While Rust isn’t set to completely replace JavaScript tools, it will likely rule where speed and power matter most.

WebAssembly (WASM) is another big advantage, it lets Rust run in the browser with JavaScript, so they can team up. Rust could handle tough jobs like processing code, while JavaScript keeps the interface smooth. This mix could make web development faster and intuitive, with both languages shining where they’re best.

With Rust eating the JavaScript tooling with its speed, and memory safety guarantees, it’s not just a passing fad, it’s changing how we build for the web.

RUST TIP 🦀

In the previous issue, we challenged you to find a solution for pairs summing to a target.

Kudos to S G, Gopal, ByteSmith, and others who took on the challenge.

Let's move on to this week’s tip.

Efficient Swapping Without Cloning

When you need to "reset" or swap out a value from a mutable reference (like a String, Vec, or any type implementing Default), std::mem::take lets you replace it with its default value and take ownership of the original value—all without cloning or unnecessary allocations.

You can use std::mem::take to reduce heap allocations. If you're more curious, check out the documentation at https://doc.rust-lang.org/std/mem/fn.take.html.

You can play around with the code on Rust Playground.

PROJECT SPOTLIGHT 💡

Boa - A Rust-Powered JavaScript Engine

Boa Logo

Boa is an experimental Javascript lexer, parser and interpreter written in Rust. Currently, it has support for some of the language.

It is designed to bring the power and safety of Rust to the world of JavaScript execution.

Native JavaScript engines, while powerful, can be prone to memory-related bugs or performance bottlenecks. By taking advantage of Rust’s memory safety and performance guarantees, Boa aims to be a reliable and efficient alternative.

Boa also has support for WebAssembly (WASM) to enable developers to experiment with JavaScript execution in various environments, from the web to CLI tools, without relying on heavyweight engines like V8.

What Makes Boa Awesome?

• Written in Rust, Boa benefits from zero-cost abstractions, fearless concurrency, and memory safety, ensuring peek performance and stability.

• Boa is split into focused crates like boa_engine (execution), boa_parser (lexer/parser), and boa_gc (garbage collection), offering flexibility for developers to use only what they need.

• With a live WASM playground, you can test Boa directly in your browser, showcasing its cross-platform potential.

• The boa_cli crate provides a command-line interface and interactive REPL, complete with options like strict mode, AST dumping, and flowgraph generation for debugging and analysis.

• Features like code profiling (boa_profiler), ICU4X integration (boa_icu_provider), and optimizer statistics make it a playground for performance enthusiasts.

Boa is a community effort pushing the boundaries of JavaScript in Rust. The project codebase is open-source on GitHub at github.com/boa-dev/boa.

AWESOME LINKS OF THE WEEK 🔗

1. The Rustup v1.28.1 release is now available. This follows v1.28.0 released last week which introduced some breaking issues, and serves as a follow-up release to address those bugs.

2. Guillaume Gomez from Huawei joined Allen Wyma on The Rustacean Station Podcast to discuss how he became involved with Rust, his contributions to the language, and his recent work. [podcast]

3. Niko Matsakis, a.k.a ‘Michelangelo of memory safety’, shared his vision for Rust's role in the computing landscape. His article, 'Rust in 2025: Targeting Foundational Software,' is a must-read.

4. Greg Schoeninger wrote an article on Training a Rust 1.5B Coder LM with Reinforcement Learning (GRPO).

5. The SeaORM team has released SeaORM 1.1, and I’m excited about support for Postgres Vector and Nested Objects in Relational Queries.

6. Ubuntu is slowly moving to Rust. Read about their latest writeup on Carefully but Purposefully Oxidising Ubuntu.

7. NoBoiletplate made an amazing video on how Rust is the New C and how Rust could be language of the next decade. [video]

8. Folkert de Vries from Trifecta Tech Foundation blogged about Translating bzip2 with c2rust.

9. Carl M. Kadie explained the peculiarities and challenges of programming the Raspberry Pi Pico's Programmable Input/Output (PIO) subsystem using the Rust programming language. Check out his article titled Nine Pico PIO Wats with Rust (Part 1)".

10. Felix Wirth penned an interesting article on When are Rust's `const fn`s executed?.

CodeCrafters: Become a Better Rust Engineer

CodeCrafters created amazing Rust courses that push your skills beyond the basics.

You’ll have fun building real-world projects from scratch, including Git, Docker, Redis, Kafka, SQLite, Grep, BitTorrent, HTTP Server, an Interpreter, and DNS.

The courses are self-paced, so you can learn at your own speed.

If you’re itching to level up your Rust skills, these courses are perfect for you.

Here’s what makes CodeCrafters stand out:

• Learn by building projects that challenge you beyond just implementing CRUD features.

• Strengthen your fundamentals by working on awesome low-level projects.

• Get really good at reading and writing idiomatic Rust code.

• Join a community of talented engineers from MAANG companies and learn best practices from the pros.

• Plus, take part in monthly contests for a chance to win exciting prizes.

You can get your CodeCrafters fees fully reimbursed through your corporate Learning & Development (L&D) budget.

Be sure to check with your employer about tapping into your L&D budget to save money and make this a no-brainer opportunity to level up your skills.

Don't take our word for it. See what others have to say. [affiliate]

SUPPORT RUST BYTES👋

You're Rust Bytes biggest fans, and we love to see it.

Here’s how you can help spread the word:

• ❤️ Recommend Rust Bytes to your friends.

• 🤳 Connect with us on our socials: X, Rustaceans Publication.

• 📨 Email us at rustaceanseditors@gmail.com for sponsorship, feedback or ideas.

• ☕️ Buy us coffee to support our editors.

I love this saying from DHH: 'The magic is in your fingers.' See you next week.

That's all for now, Rustaceans.

John & Elley.