# AI Engineering Curriculum Languages: Python, TypeScript, Rust, and Julia Explained

> Explore AI Engineering curriculum languages Python TypeScript Rust and Julia enforced with strict dependency constraints for a stdlib-first learning approach. Discover the stack.

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

---

**The AI Engineering curriculum supports exactly four programming languages—Python, TypeScript, Rust, and Julia—with strict dependency constraints defined in the repository's [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) policy file to enforce a stdlib-first learning approach.**

The **rohitg00/ai-engineering-from-scratch** repository defines its language support through a rigorous governance model outlined in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md). This curriculum deliberately restricts implementations to a concise set of languages and dependencies, ensuring learners focus on algorithmic fundamentals rather than framework-specific shortcuts. Each language serves distinct purposes within the learning path, from numerical computing to performance-critical systems and web-based agents.

## Supported Languages and Dependency Allowlists

According to the **[`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md)** Dependencies table, the curriculum permits only four languages with carefully curated third-party package allowances. This constraint forces implementations to remain portable and focused on core concepts.

### Python

**Python** implementations may use the standard library plus five specific packages: `numpy`, `torch`, `h5py`, `zstandard`, and `safetensors`. This restriction appears explicitly in the Dependencies table of [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md). Most algorithmic lessons use Python as the primary implementation language, particularly for machine learning and linear algebra foundations.

### TypeScript

**TypeScript** is permitted for web-based agents and user interfaces. The allowlist includes `hono`, `zod`, `ws` (reserved strictly for WebSocket requirements), and `@hono/node-server`, alongside the Node.js 20+ standard library. This configuration supports modern serverless architectures while maintaining strict boundary enforcement.

### Rust

**Rust** implementations must compile using single-file `rustc --edition 2021` with no external crates. The curriculum restricts Rust to the pure standard library, making it ideal for performance-critical components where zero-cost abstractions matter without dependency overhead.

### Julia

**Julia** is supported for numerical-science explorations using only standard library modules: `Random`, `Statistics`, `LinearAlgebra`, and `Printf`. These built-in packages provide sufficient functionality for mathematical foundations without requiring external dependencies.

## How Language Constraints Are Enforced

The curriculum enforces these language restrictions through lesson-level metadata and file structure validation. Each lesson's frontmatter includes a **Languages** field that must match the allowed set defined in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md).

For example, the "Linear Algebra Intuition" lesson 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) declares `Python, Julia` in its frontmatter metadata. This declaration drives the validation of accompanying code files and ensures consistency across the repository.

## Implementation Structure and Code Examples

Every lesson follows a consistent file layout where implementations reside in `code/main.<ext>` with mandatory header comments citing the lesson documentation. Below are minimal "Hello, World" examples following the curriculum's lesson contract.

### Python Example

```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 Example

```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 Example

```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 Example

```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 **rohitg00/ai-engineering-from-scratch** curriculum supports exactly four languages: **Python**, **TypeScript**, **Rust**, and **Julia**.
- Language constraints are centrally defined in the **[`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md)** Dependencies table, which specifies allowed third-party packages for each ecosystem.
- **Python** allows `numpy`, `torch`, `h5py`, `zstandard`, and `safetensors`; **TypeScript** permits `hono`, `zod`, `ws`, and `@hono/node-server`; **Rust** is restricted to the standard library only; **Julia** may use `Random`, `Statistics`, `LinearAlgebra`, and `Printf`.
- Each lesson declares its languages via frontmatter metadata (the **Languages** field in lesson markdown files), and implementations must follow the `code/main.<ext>` structure with proper header comments linking to the documentation.

## Frequently Asked Questions

### What programming languages does the AI Engineering curriculum support?

The curriculum supports **Python**, **TypeScript**, **Rust**, and **Julia**. These languages are explicitly listed in the [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) policy file and enforced through lesson metadata, with each language serving specific pedagogical purposes from numerical computing to systems programming.

### Why does the curriculum restrict third-party dependencies?

The stdlib-first approach ensures learners understand core algorithms and data structures without relying on framework-specific abstractions. By limiting external packages—such as restricting Rust to pure `rustc --edition 2021` or Python to specific scientific computing libraries—the curriculum maintains focus on fundamental AI engineering concepts rather than library-specific APIs.

### How are language requirements enforced in individual lessons?

Each lesson's markdown frontmatter includes a **Languages** field that must match the allowed set. For example, [`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) lists `Python, Julia`. Code files must be placed in `code/main.<ext>` with header comments linking back to the lesson documentation, creating a validation chain from metadata to implementation.

### Can I use external libraries not listed in AGENTS.md?

No. The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) Dependencies table serves as the sole authority for allowed packages. Using libraries outside the specified allowlist—such as additional crates in Rust or extra npm packages in TypeScript—would violate the curriculum's lesson contract and break the validation rules enforced by the repository's governance structure.