What Programming Languages Are Supported in the AI Engineering Curriculum?

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 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, 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, Julia enables high-performance numerical exploration while maintaining the curriculum's dependency-free philosophy.

Dependency Constraints and Allowed Packages

The 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.

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

• code/main.py for Python implementations
• code/main.ts for TypeScript
• 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

# 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

// 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

//! 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

# 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, 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 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 file. For example, the "Linear Algebra Intuition" lesson at 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}