swc-project/swc v1.15.26 landed on April 14, 2026, marking another point release in the Rust-based JavaScript and TypeScript compiler's steady release cadence. The project, which has been production-hardened through its integration in Next.js, Parcel, and Deno, continues to ship compatibility fixes and performance refinements without major new features in this cycle.
What Is SWC?
SWC (speedy web compiler) started as a drop-in replacement for Babel, written in Rust to take advantage of the language's performance characteristics. Where Babel runs as a JavaScript process interpreting a chain of transforms, SWC compiles those same transforms to native machine code ahead of time. The result is a compiler that processes JavaScript and TypeScript code 20 to 70 times faster than Babel, depending on the workload.
The project is organized around a core compiler crate that handles parsing, transforming, and serializing JavaScript and TypeScript code. A separate crate system exposes these transforms as isolated operations, which can be composed — similar to how Babel plugins work — but executed in a Rust runtime.
v1.15.26 Changes
The v1.15.26 release includes patches across SWC's core, common API surface, and transform passes. While this is a patch-level release, it reflects the ongoing maintenance work that keeps SWC compatible with the latest ECMAScript proposals and TypeScript syntax. The previous stable release, v1.15.24, shipped on April 4, and v1.15.25 followed shortly after — the project has been maintaining a roughly weekly patch cadence.
Key areas of ongoing work include:
- TypeScript transform compatibility — ensuring that the SWC transform for TypeScript remains aligned with the TypeScript compiler's behavior for newer TypeScript syntax features
- ES2026/ES2027 proposal support — SWC tracks the ECMAScript proposal stage process and updates its parser and transforms accordingly
- Bug fixes in the minifier — the SWC minifier competes with Terser for JavaScript output size optimization
The Rust Tooling Ecosystem
SWC exists in a crowded but healthy part of the JavaScript tooling landscape. The three major Rust-based JavaScript tool projects each occupy a different niche:
- esbuild (by Evan Wallace) — the oldest, focused on raw compilation speed
- SWC — the most Babel-compatible, deepest integration with existing frameworks
- OXC (Oxidation Compiler) — the newest, backed by the Vercel/Nx team, targeting full TypeScript type-checker coverage and Rollup-compatible bundling
SWC's advantage over the newer entrants is its track record. It has been running in production at scale inside Next.js applications for years, which means edge cases have been found and fixed. OXC is catching up fast — its latest releases (v0.125 and v0.126) have been adding TypeScript-specific transforms that previously required SWC or the TypeScript compiler itself.
The healthy competition between these three projects has raised the bar for the entire JavaScript tooling ecosystem. What would have required a Babel plugin chain running in a slow JavaScript process five years ago is now handled by native code in milliseconds.
Using SWC
For most developers, SWC is encountered indirectly through Next.js or Parcel. However, the SWC crate can be used directly as a build tool or integrated into custom tooling:
use swc_common::{sync::Lrc, FileName, SourceMap};
use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, TsSyntax};
use swc_ecma_ast::*;
use swc_ecma_codegen::Emitter;
fn main() {
let cm: Lrc<SourceMap> = Default::default();
let fm = cm.new_source_file(
FileName::Custom("example.ts".into()).into(),
"const x: number = 1;".into(),
);
let lexer = Lexer::new(
TsSyntax::default(),
Default::default(),
StringInput::from(&*fm),
None,
);
let mut parser = Parser::new_from(lexer);
let module = parser.parse_module().unwrap();
// ... transforms and codegen
}
The Rust API gives fine-grained control over the compilation pipeline. For JavaScript-based tooling, the @swc-node and @swc/core npm packages expose the same transforms.
The project maintains a nightly release channel that tracks the latest ECMAScript proposals and TypeScript features. Stable releases are cut frequently enough that most users can update without concern — breaking changes in swc are rare outside of major version bumps.
