Programming Languages Used for Multi-Language Implementation in AI Engineering From Scratch

The AI Engineering From Scratch curriculum uses Python, TypeScript, Rust, and Julia as its four first-party programming languages for multi-language implementation, with each track restricted to specific standard libraries and approved packages.

The rohitg00/ai-engineering-from-scratch repository is a multi-language learning platform that teaches AI engineering fundamentals by expressing identical mathematical and engineering principles through different runtime ecosystems. Instead of locking learners into a single stack, the project demonstrates which programming languages are used for multi-language implementation by running Python, TypeScript, Rust, and Julia side by side. Each language adheres to dependency rules listed in the repository's AGENTS.md, which explicitly defines approved runtimes and packages for every track.

Python: Core Deep Learning and Reinforcement Learning

Python serves as the primary implementation language for deep-learning, reinforcement-learning, and computer-vision lessons. The curriculum follows a stdlib-first policy, permitting only a handful of approved third-party packages such as numpy and torch.

You can see the pattern in phases/03-deep-learning-core/01-the-perceptron/code/main.py, where basic functions are implemented with minimal external dependencies:

# phases/03-deep-learning-core/01-the-perceptron/code/main.py

def greet(name: str) -> str:
    """Return a friendly greeting."""
    return f"Hello, {name}!"

print(greet("AI Engineer"))

This file demonstrates how even foundational deep-learning phases rely on clean, readable Python that emphasizes algorithmic clarity over framework magic.

TypeScript: Typed Server-Side Agents and Web Dashboards

TypeScript provides a modern, statically typed environment for server-side agents, web dashboards, and API services. The allowed runtime libraries are restricted to hono, zod, and ws, ensuring that learners work within a controlled, educational boundary.

In phases/19-capstone-projects/12-video-understanding-pipeline/code/ts/src/server.ts, the curriculum shows how to build lightweight HTTP endpoints:

// phases/19-capstone-projects/12-video-understanding-pipeline/code/ts/src/server.ts
import { Hono } from "hono";

const app = new Hono();

app.get("/", (c) => c.text("Hello, AI Engineer!"));

export default { fetch: app.fetch };

This snippet illustrates the TypeScript track's focus on type-safe networking and modular server architecture.

Rust: High-Performance Tokenizers and Real-Time Edge Vision

Rust is used for low-level, high-performance implementations such as tokenizers, inference optimizations, and real-time edge vision pipelines. The curriculum restricts Rust code to the standard library only, forcing learners to engage with memory management and zero-cost abstractions directly.

The file phases/04-computer-vision/15-real-time-edge/code/main.rs highlights this approach:

// phases/04-computer-vision/15-real-time-edge/code/main.rs
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    println!("{}", greet("AI Engineer"));
}

By limiting dependencies, the repository ensures that learners understand Rust's ownership model and performance characteristics without relying on external crates.

Julia: Scientific Computing for Transformers and Linear Algebra

Julia offers a scientific-computing perspective optimized for linear-algebra-heavy topics like transformers and singular value decomposition (SVD). The Julia track is limited to its standard library modules—such as Random and Statistics—so learners can focus on numerical methods and matrix operations.

A representative file is phases/07-transformers-deep-dive/01-why-transformers/code/main.jl:

# phases/07-transformers-deep-dive/01-why-transformers/code/main.jl

greet(name) = "Hello, $(name)!"

println(greet("AI Engineer"))

This phase demonstrates Julia's concise syntax for mathematical functions while keeping the dependency surface minimal.

Cross-Language Design Goals and Dependency Governance

The repository's AGENTS.md explicitly lists these four languages in its Dependencies table, codifying the allowed runtimes and packages for each track. The overarching design goal is to let learners see the same algorithmic concepts—from perceptrons to transformers—expressed in different syntactic and runtime contexts.

Because each language operates under strict library constraints, learners can compare:

• Python for rapid prototyping and deep-learning ergonomics.
• TypeScript for type-safe API and agent development.
• Rust for systems-level performance and edge deployment.
• Julia for high-level scientific computing and linear algebra.

This structure reinforces the underlying mathematics and engineering principles without letting framework-specific APIs obscure the core lessons.

Summary

• The rohitg00/ai-engineering-from-scratch repository is a multi-language implementation of AI engineering fundamentals that uses Python, TypeScript, Rust, and Julia.
• Python handles deep-learning core lessons at phases/03-deep-learning-core/01-the-perceptron/code/main.py with a stdlib-first policy and approved packages like numpy and torch.
• TypeScript powers server-side agents and dashboards, as seen in phases/19-capstone-projects/12-video-understanding-pipeline/code/ts/src/server.ts, using restricted libraries such as hono.
• Rust targets low-level, performance-critical code at phases/04-computer-vision/15-real-time-edge/code/main.rs, relying exclusively on the Rust standard library.
• Julia covers scientific-computing topics like transformers at phases/07-transformers-deep-dive/01-why-transformers/code/main.jl using only standard library modules.
• All four tracks are governed by the dependency rules in AGENTS.md, ensuring that learners focus on algorithms rather than external frameworks.

Frequently Asked Questions

What programming languages are used in the AI Engineering From Scratch repository?

The repository uses four first-party languages: Python, TypeScript, Rust, and Julia. Each language is assigned a specific pedagogical role, from Python's deep-learning core to Julia's scientific-computing focus.

Why does the curriculum restrict third-party libraries?

The AGENTS.md file enforces a standard-library-first policy to prevent framework abstractions from masking the underlying algorithms. Approved packages are limited to essentials like numpy, torch, hono, zod, and ws, keeping the educational focus on language mechanics and math.

Where can I find the Rust implementation of computer vision topics?

The Rust track for real-time edge vision is located at phases/04-computer-vision/15-real-time-edge/code/main.rs. This file demonstrates how the curriculum teaches systems-level AI concepts without external crates.

How does the multi-language implementation help learners?

By expressing identical concepts across Python, TypeScript, Rust, and Julia, the curriculum lets learners compare syntax, memory models, type systems, and performance trade-offs. This reinforces the idea that AI engineering principles are language-agnostic even though runtimes and ecosystems differ.

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