feat(vite-plugin-angular): add OXC engine adapter for fastCompile

.github/workflows/conformance.yml

@@ -20,12 +20,16 @@ env:
 jobs:
   conformance:
     runs-on: ubuntu-latest
+    # OXC engine rows are advisory while it's an opt-in compiler — drift
+    # signal without blocking PR merges. TS engine rows stay required.
+    continue-on-error: ${{ matrix.engine == 'oxc' }}
     strategy:
       fail-fast: false
       matrix:
         angular-major: [17, 18, 19, 20, 21, 'latest', 'next']
+        engine: [ts, oxc]
 
-    name: Angular ${{ matrix.angular-major }}
+    name: Angular ${{ matrix.angular-major }} (engine=${{ matrix.engine }})
 
     steps:
       - uses: actions/checkout@v3
@@ -46,4 +50,8 @@ jobs:
       - name: Run conformance tests
         env:
           ANGULAR_SOURCE_DIR: .angular-conformance
-        run: pnpm exec vitest run packages/vite-plugin-angular/src/lib/compiler/conformance.spec.ts
+          CONFORMANCE_ENGINE: ${{ matrix.engine }}
+        # OXC's NAPI binary crashes vitest's default isolated forks pool.
+        # `--no-isolate` runs all spec files in a single shared worker,
+        # which the binary survives. Identical pass rate, harmless on TS.
+        run: pnpm exec vitest run packages/vite-plugin-angular/src/lib/compiler/conformance.spec.ts --no-isolate

apps/docs-app/docs/guides/angular-compilation.md

@@ -0,0 +1,152 @@
+# Angular Compilation
+
+Analog compiles your Angular components, directives, and pipes to Ivy definitions during the Vite build. There are two compilation paths:
+
+- **Default compilation** — Angular's own compiler (`ngtsc`), with full compile-time type checking.
+- **OXC-based engine** — a native Rust compiler that produces the same Ivy output much faster.
+
+Both emit identical Ivy code and identical runtime behavior, because both ultimately call the same `@angular/compiler` lowering APIs.
+
+## Default compilation
+
+This is what you get out of the box — no configuration required:
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import angular from '@analogjs/vite-plugin-angular';
+
+export default defineConfig({
+  plugins: [angular()],
+});
+```
+
+The default path runs Angular's compiler through the Angular Compilation API. It performs **full TypeScript and template type checking** (including `strictTemplates`), emits declaration files, and supports i18n message extraction. Use it when you want compile-time safety — wrong template bindings, missing inputs, and type mismatches fail the build.
+
+## OXC-based engine
+
+The OXC-based engine swaps Angular's compiler for [`@oxc-angular/vite`](https://github.com/voidzero-dev/oxc-angular-compiler) — the **OXC Angular compiler**, a native Rust port of Angular's component compiler. It produces equivalent Ivy output and reduces cold-build and hot-rebuild times, since it never constructs a full `ts.Program`.
+
+### Enabling
+
+`@oxc-angular/vite` is an optional peer dependency — install it alongside Analog:
+
+```bash
+npm install -D @oxc-angular/vite
+```
+
+Then opt in via the `angular()` plugin:
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import angular from '@analogjs/vite-plugin-angular';
+
+export default defineConfig({
+  plugins: [
+    angular({
+      fastCompile: 'oxc',
+    }),
+  ],
+});
+```
+
+:::note
+In an Analog application, configure the plugin through `@analogjs/platform` instead — its `analog()` plugin forwards the same `fastCompile` option:
+
+```ts
+import analog from '@analogjs/platform';
+
+export default defineConfig({
+  plugins: [analog({ fastCompile: 'oxc' })],
+});
+```
+
+:::
+
+You can also enable the engine without editing your config by setting the `ANALOG_OXC=true` environment variable — useful for trying it in CI. An explicit `fastCompile` in your config takes precedence.
+
+### What it supports
+
+| Capability                                   | OXC-based engine                                                       |
+| -------------------------------------------- | ---------------------------------------------------------------------- |
+| AOT compilation (`ɵɵdefineComponent`)        | ✅ Native Rust pipeline                                                |
+| JIT compilation                              | ✅                                                                     |
+| Inline `template:` / `styles:`               | ✅ Inline SCSS / Sass / Less is preprocessed before compilation        |
+| External `templateUrl` / `styleUrl`          | ✅ Resolved and preprocessed via Vite                                  |
+| Hot Module Replacement (HMR)                 | ✅                                                                     |
+| Style encapsulation                          | ✅                                                                     |
+| Cross-file selector resolution               | ✅                                                                     |
+| Library / partial builds (`compilationMode`) | ✅ Emits partial declarations and Ivy `.d.ts` type members (see below) |
+| Compile-time template type checking          | ❌ Use the Angular Language Service in your editor                     |
+
+### Building a library
+
+For a library build (`fastCompileMode: 'partial'`), the OXC engine emits the partial `ɵɵngDeclare*` declarations and augments the emitted `.d.ts` with Angular's Ivy type members (`ɵfac`, `ɵcmp`, …) so consumers get full template type-checking against your published package.
+
+The base `.d.ts` files themselves must be produced by a declaration generator (`rolldown-plugin-dts`, `vite-plugin-dts`, `tsdown`, or `tsc`); the OXC engine augments those declarations rather than generating them. See [Building an Angular library](/docs/guides/libraries).
+
+## Type checking
+
+The OXC engine does not type-check your templates or TypeScript. To catch those errors, run Angular's compiler as a separate verification step against your app's tsconfig. Pass `--noEmit` so it only reports errors without writing output:
+
+```bash
+ngc -p tsconfig.app.json --noEmit
+```
+
+Add it as a script and run it alongside your build:
+
+```json
+// package.json
+{
+  "scripts": {
+    "typecheck": "ngc -p tsconfig.app.json --noEmit"
+  }
+}
+```
+
+This keeps fast builds during development while still failing on template and type errors before you ship — and the Angular Language Service surfaces the same errors live in your editor.
+
+## Compatibility
+
+### Angular versions
+
+The OXC Angular compiler supports **Angular 19–22**.
+
+| Angular Version | OXC-based engine |
+| --------------- | ---------------- |
+| ^22.0.0         | ✅               |
+| ^21.0.0         | ✅               |
+| ^20.0.0         | ✅               |
+| ^19.0.0         | ✅               |
+
+For overall Angular/Analog/Vite version support, see [Version Compatibility](/docs/guides/compatibility).
+
+### Compiler package
+
+| Analog Version | `@oxc-angular/vite` |
+| -------------- | ------------------- |
+| **latest**     | ^0.0.31             |
+
+### Default vs OXC-based engine
+
+|                                     | Default                 | OXC-based engine                           |
+| ----------------------------------- | ----------------------- | ------------------------------------------ |
+| Engine                              | Angular (`ngtsc`)       | Native Rust (`@oxc-angular/vite`)          |
+| Ivy output                          | Full                    | Identical                                  |
+| Cold build / hot rebuild            | Standard                | Significantly faster                       |
+| Compile-time template type checking | Yes (`strictTemplates`) | No — use the Angular Language Service      |
+| i18n message extraction             | Yes                     | `$localize` emitted (extraction not wired) |
+| Library / partial + `.d.ts`         | Yes                     | Yes (`.d.ts` augmented)                    |
+| Status                              | Stable                  | Experimental                               |
+
+## Caveat
+
+:::caution
+The OXC Angular compiler is **experimental** and trades compile-time safety for speed.
+
+- **No compile-time template type checking.** The OXC engine emits identical Ivy output and identical runtime behavior, but it does not validate template bindings, inputs, or types at build time. Run the **Angular Language Service** in your editor to catch these errors as you type — they appear as editor squiggles instead of failing the build.
+- **Optional peer dependency.** The engine requires `@oxc-angular/vite` to be installed. If it is missing, enabling `fastCompile: 'oxc'` throws a clear error at startup.
+
+If you need template type errors to fail your build (for example in CI), add the [type-checking step](#type-checking) or use the default compilation path.
+:::

apps/docs-app/sidebars.js

@@ -211,6 +211,11 @@ const sidebars = {
           id: 'guides/libraries',
           label: 'Building an Angular library',
         },
+        {
+          type: 'doc',
+          id: 'guides/angular-compilation',
+          label: 'Angular Compilation',
+        },
         {
           type: 'doc',
           id: 'guides/compatibility',

package.json

@@ -118,7 +118,7 @@
     "@nx/vite": "22.7.5",
     "@nx/vitest": "22.7.5",
     "@nx/web": "22.7.5",
-    "@oxc-angular/vite": "^0.0.15",
+    "@oxc-angular/vite": "^0.0.31",
     "@oxc-project/runtime": "^0.117.0",
     "@playwright/test": "^1.58.2",
     "@schematics/angular": "21.1.5",

packages/platform/src/lib/options.ts

@@ -124,10 +124,23 @@ export interface Options {
    */
   disableTypeChecking?: boolean;
   /**
-   * Opt into the fast compile path. Skips Angular's template type-checking
-   * and routes compilation through an internal single-pass transform.
-   */
-  fastCompile?: boolean;
+   * Opt into the fast compile path and select the engine that backs it. The
+   * fast path skips Angular's template type-checking and routes compilation
+   * through an internal single-pass transform.
+   * - `false` (default) / unset: use Angular's full compilation (with
+   *   template type-checking).
+   * - `true` or `'ts'`: the in-process TS/OXC-AST compiler shipped with
+   *   `@analogjs/vite-plugin-angular`.
+   * - `'oxc'`: experimental — route AOT and JIT component compilation through
+   *   the native Rust pipeline from `@oxc-angular/vite` (must be installed as
+   *   an optional peer dependency). Also unlocks OXC's `@ng/component` HMR
+   *   contract, library linker (`linkAngularPackage`), and FESM build
+   *   optimizer (`optimizeAngularPackage`).
+   *
+   * The OXC engine can also be selected with the `ANALOG_OXC=true` environment
+   * variable when this option is left unset (explicit values take precedence).
+   */
+  fastCompile?: boolean | 'ts' | 'oxc';
   /**
    * Compilation output mode used when `fastCompile` is enabled.
    * - `'full'` (default): Emit final Ivy definitions for application builds.

packages/vite-plugin-angular/package.json

@@ -26,6 +26,7 @@
   "peerDependencies": {
     "@angular-devkit/build-angular": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/build": "^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
+    "@oxc-angular/vite": "^0.0.31",
     "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "peerDependenciesMeta": {
@@ -35,6 +36,9 @@
     "@angular/build": {
       "optional": true
     },
+    "@oxc-angular/vite": {
+      "optional": true
+    },
     "vite": {
       "optional": true
     }

packages/vite-plugin-angular/src/lib/angular-vite-plugin.ts

@@ -63,6 +63,7 @@ import {
 import { routerPlugin } from './router-plugin.js';
 import { createHash } from 'node:crypto';
 import { fastCompilePlugin } from './fast-compile-plugin.js';
+import { oxcLinkerPlugin } from './compiler/oxc-linker-plugin.js';
 import {
   TS_EXT_REGEX,
   createTsConfigGetter,
@@ -107,11 +108,21 @@ export interface PluginOptions {
   disableTypeChecking?: boolean;
   fileReplacements?: FileReplacement[];
   /**
-   * Opt into the fast compile path. Skips Angular's template type-checking
-   * and routes compilation through an internal single-pass transform.
-   * Defaults to `false`.
+   * Opt into the fast compile path and select the engine that backs it. The
+   * fast path skips Angular's template type-checking and routes compilation
+   * through an internal single-pass transform.
+   * - `false` (default) / unset: use Angular's full compilation (with
+   *   template type-checking).
+   * - `true` or `'ts'`: the in-process TS/OXC-AST compiler shipped with this
+   *   package.
+   * - `'oxc'`: experimental — route component compilation through the native
+   *   Rust pipeline from `@oxc-angular/vite` (must be installed as an optional
+   *   peer dependency).
+   *
+   * The OXC engine can also be selected with the `ANALOG_OXC=true` environment
+   * variable when this option is left unset (explicit values take precedence).
    */
-  fastCompile?: boolean;
+  fastCompile?: boolean | 'ts' | 'oxc';
   /**
    * Compilation output mode used when `fastCompile` is enabled.
    * - `'full'` (default): Emit final Ivy definitions for application builds.
@@ -149,6 +160,15 @@ export function angular(options?: PluginOptions): Plugin[] {
    * Normalize plugin options so defaults
    * are used for values not provided.
    */
+  // Resolve the consolidated `fastCompile` option (boolean | 'ts' | 'oxc')
+  // into an internal enabled flag + engine. `ANALOG_OXC=true` selects the OXC
+  // engine when the option is unset; explicit config takes precedence.
+  const oxcEngineFromEnv = process.env['ANALOG_OXC'] === 'true';
+  const fastCompileValue =
+    options?.fastCompile ?? (oxcEngineFromEnv ? 'oxc' : false);
+  const fastCompileEngine: 'ts' | 'oxc' =
+    fastCompileValue === 'oxc' ? 'oxc' : 'ts';
+
   const pluginOptions = {
     tsconfigGetter: createTsConfigGetter(options?.tsconfig),
     workspaceRoot: options?.workspaceRoot ?? process.cwd(),
@@ -170,8 +190,9 @@ export function angular(options?: PluginOptions): Plugin[] {
     fileReplacements: options?.fileReplacements ?? [],
     useAngularCompilationAPI:
       options?.experimental?.useAngularCompilationAPI ?? false,
-    fastCompile: options?.fastCompile ?? false,
+    fastCompile: fastCompileValue !== false,
     fastCompileMode: options?.fastCompileMode ?? 'full',
+    fastCompileEngine,
   };
 
   let resolvedConfig: ResolvedConfig;
@@ -820,12 +841,34 @@ export function angular(options?: PluginOptions): Plugin[] {
         isTest,
         isAstroIntegration,
         fastCompileMode: pluginOptions.fastCompileMode,
+        fastCompileEngine: pluginOptions.fastCompileEngine,
       })
     : angularPlugin();
 
+  // OXC engine only: link pre-compiled Angular libraries (`ɵɵngDeclare*`
+  // → `ɵɵdefine*`) using OXC's native Rust linker. Without this, those
+  // libraries fall back to runtime JIT linking which pulls
+  // `@angular/compiler` into the browser bundle. Skipped on the TS
+  // engine path, which has its own dts-reader covering the same need.
+  const linkerPlugin =
+    pluginOptions.fastCompile && pluginOptions.fastCompileEngine === 'oxc'
+      ? oxcLinkerPlugin()
+      : (false as unknown as Plugin);
+
+  // Both engines use Analog's `JavaScriptTransformer`-backed optimizer.
+  // OXC's `optimizeAngularPackage` leaves `@angular/core/fesm2022/core.mjs`
+  // essentially untouched, so unused public re-exports (including the JIT
+  // runtime) survive tree-shaking and ~150KB extra ships to the client.
+  // Revisit `oxcOptimizerPlugin` once upstream closes the gap.
+  const optimizerPlugin = buildOptimizerPlugin({
+    supportedBrowsers: pluginOptions.supportedBrowsers,
+    jit,
+  });
+
   return [
     replaceFiles(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
     compilationPlugin,
+    linkerPlugin,
     !pluginOptions.fastCompile &&
       pluginOptions.liveReload &&
       liveReloadPlugin({ classNames, fileEmitter }),
@@ -836,14 +879,13 @@ export function angular(options?: PluginOptions): Plugin[] {
       jitPlugin({
         inlineStylesExtension: pluginOptions.inlineStylesExtension,
       })) as Plugin,
-    buildOptimizerPlugin({
-      supportedBrowsers: pluginOptions.supportedBrowsers,
-      jit,
-    }),
+    optimizerPlugin,
     routerPlugin(),
     angularFullVersion < 190004 && pendingTasksPlugin(),
     nxFolderPlugin(),
-  ].filter(Boolean) as Plugin[];
+  ]
+    .flat()
+    .filter(Boolean) as Plugin[];
 
   function findIncludes() {
     const workspaceRoot = normalizePath(resolve(pluginOptions.workspaceRoot));