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

> Explore the programming languages used in AI Engineering From Scratch: Python, TypeScript, Rust, and Julia. Discover multi-language implementation strategies for robust AI development.

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

---

**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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/03-deep-learning-core/01-the-perceptron/code/main.py), where basic functions are implemented with minimal external dependencies:

```python

# 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/12-video-understanding-pipeline/code/ts/src/server.ts), the curriculum shows how to build lightweight HTTP endpoints:

```typescript
// 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/04-computer-vision/15-real-time-edge/code/main.rs) highlights this approach:

```rust
// 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`:

```julia

# 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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.