A high-performance Angular template compiler written in Rust, leveraging the Oxc infrastructure for blazing-fast compilation.

• Rust-Powered Performance - Native compilation via NAPI-RS for maximum speed
• Vite Integration - First-class Vite plugin with full HMR support
• Drop-in Compatible - API compatible with @angular/compiler-cli
• Full Angular Support - Components, directives, pipes, injectables, and NgModules
• Hot Module Replacement - Fast refresh for templates and styles during development
• Style Encapsulation - ViewEncapsulation.Emulated, None, and ShadowDom support
• i18n Ready - Message extraction with XLIFF 1.2/2.0, XMB, and XTB formats
• Build Optimizations - Constant folding, pure function extraction, unused code removal

npm install @oxc-angular/vite
# or
pnpm add @oxc-angular/vite
# or
yarn add @oxc-angular/vite

// vite.config.ts
import { defineConfig } from 'vite'
import { angular } from '@oxc-angular/vite'

export default defineConfig({
  plugins: [
    angular({
      // Optional configuration
      angularVersion: { major: 21, minor: 0, patch: 0 },
      liveReload: true,
    }),
  ],
})

import { compileTemplate, transformAngularFile } from '@oxc-angular/vite/api'

// Compile a template string
const result = await compileTemplate(
  '<div>{{ message }}</div>',
  'AppComponent',
  'app.component.ts',
  {
    angularVersion: { major: 21, minor: 0, patch: 0 },
    hmr: false,
  },
)

console.log(result.code)

// Transform an entire Angular file
const transformed = await transformAngularFile(
  `
  import { Component } from '@angular/core';

  @Component({
    selector: 'app-root',
    template: '<h1>Hello {{ name }}</h1>',
  })
  export class AppComponent {
    name = 'World';
  }
  `,
  'app.component.ts',
)

console.log(transformed.code)

Compiles an Angular template string to JavaScript.

Returns: Promise<TemplateCompileResult>

Transforms an Angular TypeScript file, compiling any component templates.

Returns: Promise<TransformResult>

interface TransformOptions {
  // Angular version (19, 20, 21)
  angularVersion?: {
    major: number
    minor: number
    patch: number
  }

  // Enable Hot Module Replacement
  hmr?: boolean

  // Enable cross-file type elision
  enableCrossFileElision?: boolean

  // i18n configuration
  i18nNormalizeLineEndingsInIcus?: boolean
  i18nUseExternalIds?: boolean

  // Style encapsulation mode
  // 'emulated' | 'none' | 'shadow-dom'
  encapsulation?: string
}

The compiler implements a 6-stage pipeline:

HTML Template
      ↓
   PARSING        → HTML AST
      ↓
  TRANSFORM       → R3 AST (Angular's internal representation)
      ↓
  INGESTION       → Intermediate Representation (IR)
      ↓
TRANSFORMATION    → 67 optimization phases
      ↓
   EMISSION       → Output AST
      ↓
CODE GENERATION   → JavaScript

Pre-built binaries are available for:

• Node.js 20.19.0+ or 22.12.0+
• Vite 6.0.0+ (for Vite plugin)

• Rust 1.90.0+
• Node.js 20.19.0+
• pnpm

# Clone the repository
git clone https://github.com/voidzero-dev/oxc-angular-compiler.git
cd oxc-angular-compiler

# Install dependencies
pnpm install

# Initialize submodules
git submodule update --init

# Build NAPI bindings
pnpm build

# Run tests
pnpm test

# Build (development)
pnpm build-dev

# Run Rust tests
cargo test

# Run Node.js tests
pnpm test

# Run E2E tests
pnpm test:e2e

# Run conformance tests against Angular
cargo run -p oxc_angular_conformance

# Start playground
pnpm playground

oxc-angular-compiler/
├── crates/
│   ├── oxc_angular_compiler/     # Core Rust compiler
│   └── angular_conformance/      # Conformance testing
├── napi/
│   └── angular-compiler/
│       ├── src/                  # NAPI bindings
│       ├── vite-plugin/          # Vite plugin (TypeScript)
│       ├── e2e/                  # E2E tests
│       └── test/                 # Integration tests
└── Cargo.toml                    # Rust workspace

Measured on Apple M3 Max (16 cores, 128 GB RAM), Node.js 22.22.0, 3 iterations averaged.

cd napi/angular-compiler/benchmarks/bitwarden

# Install dependencies
pnpm install

# Run full benchmark (cold + incremental, 3 iterations)
pnpm benchmark

# Cold build only
pnpm benchmark --cold

# Vite/OXC only (no baseline comparison)
pnpm benchmark --vite-only

# Custom iteration count
pnpm benchmark --iterations=5

See napi/angular-compiler/benchmarks/ for additional benchmark targets.

Contributions are welcome! Please read the contributing guidelines before submitting pull requests.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

• Oxc - The JavaScript Oxidation Compiler
• Angular - The Angular framework
• Vite - Next generation frontend tooling

• The Oxc team for the excellent Rust infrastructure
• The Angular team for the original compiler architecture