# What Programming Languages Are Supported in the AI Engineering Curriculum?

> Explore the AI Engineering from Scratch curriculum's supported programming languages: Python, TypeScript, Rust, and Julia. Learn fundamentals with strict dependency lists.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: getting-started
- Published: 2026-06-13

---

**The AI Engineering from Scratch curriculum supports four core languages: Python, TypeScript, Rust, and Julia, each with a strict, enumerated list of allowed dependencies to keep the focus on fundamentals rather than framework-specific abstractions.**

The open-source repository `rohitg00/ai-engineering-from-scratch` implements a **stdlib-first** educational philosophy that deliberately restricts the programming languages supported in the AI Engineering curriculum to four carefully selected ecosystems. According to the project's [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) operating manual, these constraints ensure learners master core algorithmic concepts without relying on high-level framework abstractions.

## Supported Programming Languages in the AI Engineering Curriculum

### Python: The Primary Algorithmic Language

Python serves as the default implementation language for most algorithmic lessons. According to the **Dependencies** table in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md), the curriculum permits only specific third-party packages: `numpy`, `torch`, `h5py`, `zstandard`, and `safetensors`, alongside the Python standard library. This restriction ensures that deep learning implementations remain transparent and educational rather than obscured by framework-specific magic.

### TypeScript: Web Agents and UI Layer

TypeScript handles web-based agents and user interfaces, constrained to the Node 20+ standard library plus `hono`, `zod`, `@hono/node-server`, and `ws` (reserved exclusively for WebSocket implementations). This limited ecosystem prevents dependency bloat in agent engineering phases while maintaining type safety for production-ready interfaces.

### Rust: Systems and Performance-Critical Components

For low-level performance optimization, the curriculum allows **Rust** with a pure standard library restriction. All implementations must compile as single-file scripts using `rustc --edition 2021` without external crates. This forces learners to engage with memory management and systems programming fundamentals directly.

### Julia: Numerical Science and Mathematical Foundations

Julia supports mathematical foundation lessons, restricted to standard library modules including `Random`, `Statistics`, `LinearAlgebra`, and `Printf`. As seen in lessons like "Linear Algebra Intuition" located at [`phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md), Julia enables high-performance numerical exploration while maintaining the curriculum's dependency-free philosophy.

## Dependency Constraints and Allowed Packages

The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file functions as the central policy document governing the programming languages supported in the AI Engineering curriculum. The **Dependencies** table explicitly enumerates allowed third-party packages:

| Language | Allowed Third-Party Packages |
|----------|-----------------------------|
| **Python** | `numpy`, `torch`, `h5py`, `zstandard`, `safetensors` |
| **TypeScript** | `hono`, `zod`, `ws`, `@hono/node-server` |
| **Rust** | None (stdlib only) |
| **Julia** | None (stdlib modules only) |

This whitelist approach prevents learners from importing high-level utilities that would shortcut the educational objectives of each lesson.

## Language Enforcement in Lesson Metadata

Each lesson's front-matter includes a **Languages** field that must match one of the supported ecosystems. For example, the "Linear Algebra Intuition" lesson declares `Python, Julia` in its metadata at [`phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md).

Corresponding code implementations must follow the `code/main.<ext>` convention:

- [`code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/main.py) for Python implementations
- [`code/main.ts`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/main.ts) for TypeScript
- [`code/main.rs`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/code/main.rs) for Rust
- `code/main.jl` for Julia

Each file must include a header comment citing the lesson's documentation path, adhering to the curriculum's **Lesson contract** requirements.

## Minimal Implementation Examples

The following snippets demonstrate the required file structure and header comment format for each supported language.

### Python Implementation

```python

# Linear Algebra Intuition – Python implementation

# docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md

def hello():
    print("Hello, AI Engineering (Python)")

if __name__ == "__main__":
    hello()

```

### TypeScript Implementation

```typescript
// Agent Workbench – TypeScript implementation
// docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/42-agent-workbench-capstone/docs/en.md

export function hello(): void {
  console.log("Hello, AI Engineering (TypeScript)");
}

if (require.main === module) {
  hello();
}

```

### Rust Implementation

```rust
//! Agent Harness – Rust implementation
//! docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/42-agent-workbench-capstone/docs/en.md

fn main() {
    println!("Hello, AI Engineering (Rust)");
}

```

### Julia Implementation

```julia

# Linear Algebra Intuition – Julia implementation

# docs/en.md: https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md

function hello()
    println("Hello, AI Engineering (Julia)")
end

hello()

```

## Summary

- The AI Engineering curriculum supports exactly **four programming languages**: Python, TypeScript, Rust, and Julia.
- Each language operates under a **strict dependency allowlist** defined in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md), with Rust and Julia restricted to standard libraries only.
- Python implementations allow `numpy`, `torch`, `h5py`, `zstandard`, and `safetensors` for deep learning fundamentals.
- TypeScript supports web agent development through `hono`, `zod`, and WebSocket libraries.
- Lesson metadata enforces these constraints through the **Languages** field in front-matter, while code files must follow the `code/main.<ext>` naming convention.

## Frequently Asked Questions

### Can I use other languages like Go or C++ in the curriculum?

No. The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) policy document explicitly restricts implementations to Python, TypeScript, Rust, and Julia. This constraint ensures curriculum maintainability and guarantees that all learners can focus on algorithmic fundamentals without navigating disparate language ecosystems.

### Why does the curriculum restrict third-party packages so strictly?

The **stdlib-first** philosophy prevents learners from relying on high-level abstractions that obscure core AI engineering concepts. By limiting Python to essential numerical libraries and banning external crates in Rust, the curriculum forces direct engagement with algorithms, memory management, and mathematical foundations.

### How do I know which language to use for a specific lesson?

Check the **Languages** field in the lesson's front-matter within its [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md) file. For example, the "Linear Algebra Intuition" lesson at [`phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-math-foundations/01-linear-algebra-intuition/docs/en.md) specifies both Python and Julia as valid implementation options, allowing you to choose based on your learning objectives.

### Are there any exceptions to the WebSocket restriction in TypeScript?

The `ws` package is permitted **only when WebSockets are explicitly required** for real-time agent communication. For standard HTTP servers or REST APIs, the curriculum expects use of `hono` and `@hono/node-server` without additional WebSocket libraries.