High-performance Angular AOT compiler written in Rust, providing full static compilation of Angular components and directives.

Overall Progress: ~85% Complete
Status: ✅ Functional - Can compile Angular components to JavaScript

• Rust 1.70+
• Cargo

# Build the compiler
cargo build -p angular-compiler-cli --release

# Compile an Angular project
cargo run -p angular-compiler-cli --bin ngc -- -p demo-app/tsconfig.json

Output files will be generated in demo-app/rust-output/.

rust-compiler/
├── packages/
│   ├── compiler/                  # Core Angular compiler
│   │   ├── src/
│   │   │   ├── expression_parser/ # Expression parsing
│   │   │   ├── ml_parser/         # HTML/template parsing
│   │   │   ├── template/          # Template pipeline
│   │   │   │   └── pipeline/      # IR & optimization phases
│   │   │   ├── render3/           # Render3 code generation
│   │   │   ├── output/            # AST & JavaScript emission
│   │   │   └── shadow_css/        # CSS scoping
│   │   └── Cargo.toml
│   │
│   └── compiler-cli/              # CLI interface
│       ├── src/
│       │   ├── ngtsc/             # Angular TypeScript Compiler
│       │   │   ├── core/          # Core compilation logic
│       │   │   ├── metadata/      # Metadata extraction
│       │   │   └── annotations/   # Decorator handlers
│       │   └── main.rs            # CLI entry point
│       └── Cargo.toml
│
├── demo-app/                      # Example Angular app
│   ├── src/app/
│   │   ├── app.ts                 # Main component
│   │   └── app.html               # Template
│   ├── rust-output/               # Compiled output
│   └── tsconfig.json
│
└── Cargo.toml                     # Workspace config

cargo run -p angular-compiler-cli --bin ngc -- -p path/to/tsconfig.json

// app.ts
@Component({
  selector: "app-root",
  templateUrl: "./app.html",
  styleUrls: ["./app.css"],
  changeDetection: ChangeDetectionStrategy.OnPush,
  standalone: true,
  imports: [CommonModule],
})
export class App {
  title = input<string>("Hello");
  count = signal(0);
  items = signal([{ id: 1, name: "Item 1" }]);

  clicked = output<void>();
}

<!-- app.html -->
<h1>{{ title() }}</h1>
@for (item of items(); track item.id; let idx = $index) {
<div>{{ idx + 1 }}. {{ item.name }}</div>
}

// app.js
import * as i0 from "@angular/core";

function App_For_1_Template(rf, ctx) {
  if (rf & 1) {
    i0.ɵɵelementStart(0, "div");
    i0.ɵɵtext(1);
    i0.ɵɵelementEnd();
  }
  if (rf & 2) {
    const item_r1 = ctx.$implicit;
    const $index_r2 = ctx.$index;
    i0.ɵɵadvance();
    i0.ɵɵtextInterpolate2("", $index_r2 + 1, ". ", item_r1.name, "");
  }
}

export class App {
  // ... class body
  static ɵcmp = i0.ɵɵdefineComponent({
    type: App,
    selectors: [["app-root"]],
    inputs: { title: [1, "title"] },
    outputs: { clicked: "clicked" },
    changeDetection: 0,
    standalone: true,
    // ...
  });
}

# All compiler tests
cargo test -p angular-compiler

# All compiler-cli tests
cargo test -p angular-compiler-cli

# Specific test suite
cargo test -p angular-compiler ml_parser
cargo test -p angular-compiler expression_parser

Known Issue: @for inside @if/@else blocks may cause nextContext() to return undefined in event handlers. Investigating.

• ✅ Full Template Syntax: *ngFor="let item of items; index as i; first as isFirst; last as isLast; even as isEven; odd as isOdd; trackBy: trackFn"
• ✅ Context Variables: All loop variables ($implicit, index, count, first, last, even, odd) correctly mapped
• ✅ Source-Span Sorting: Attributes in consts array are sorted by their source position in the template, ensuring parity with NGTSC
• ✅ Nested Loops: Full support for nested *ngFor with correct view restoration
• ✅ Event Handlers Inside Loops: Proper getCurrentView()/restoreView() emission for event handlers within loop bodies

• ✅ Basic Conditionals: *ngIf="condition"
• ✅ Else Template: *ngIf="condition; else elseTemplate" with TemplateRef extraction
• ✅ Then/Else Templates: *ngIf="condition; then thenTpl; else elseTpl"
• ✅ As Syntax: *ngIf="user$ | async as user" with local variable binding
• ✅ Nested NgIf: Complex nested conditionals with proper context isolation

• ✅ ɵɵtwoWayListener: Proper two-way listener emission
• ✅ ɵɵtwoWayProperty: Property binding for two-way data flow
• ✅ ɵɵtwoWayBindingSet: Setter with fallback assignment

• ✅ RestoreView Optimization: Single-usage context variables are inlined (const user = restoreView().$implicit) while multi-usage retains separate statements
• ✅ Variable Naming Parity: Global monotonic variable naming (_r1, _r2, ...) matches NGTSC exactly
• ✅ Consts Array Parity: Attribute ordering and marker values (3 for bindings, 4 for template directives) match NGTSC
• ✅ OnPush Optimization: Root view listeners skip unnecessary restoreView()/resetView() calls for OnPush components
• ✅ Listener Element Association: Correctly associates listeners with their parent elements for proper consts array ordering

• ✅ Event Binding Emission: Full support for (click)="handler()" with proper ɵɵlistener() emission
• ✅ Rolldown/Vite Integration: Angular Linker plugin for Rolldown bundler compatibility
• ✅ Deterministic Build Output: HashMap → IndexMap for consistent ordering of inputs, outputs
• ✅ Signal Inputs/Outputs: Full support for input(), input.required(), and output() signals

• i18n: Not fully implemented
• Lazy Loading: Deferred blocks partially supported
• Animations: Basic support only
• View Encapsulation: Only Emulated mode
• Source Maps: Not yet implemented

• Complete i18n support
• Full animation support
• Source map generation
• Angular CLI integration
• Incremental compilation
• Watch mode

MIT - Same as Angular

Built with ❤️ using Rust