# Core Languages for the AI Engineering from Scratch Project: Python, TypeScript, Rust, and Julia

> Explore the core languages for AI Engineering from Scratch: Python, TypeScript, Rust, and Julia. Learn fundamental algorithms with a strict standard-library-first approach.

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

---

**The AI Engineering from Scratch curriculum restricts all lessons to four core languages—Python, TypeScript, Rust, and Julia—enforcing a strict standard-library-first policy to teach fundamental algorithms without framework abstraction.**

The [rohitg00/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch) repository provides a comprehensive curriculum designed to teach AI engineering fundamentals from the ground up. According to the project's [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file, the core languages for the AI Engineering from Scratch project are deliberately limited to four specific runtimes to maintain pedagogical clarity. Each lesson requires a runnable `main.<ext>` file written in one of these languages, ensuring learners interact with raw mathematical implementations rather than high-level framework APIs.

## The Four Core Languages of the Curriculum

The repository's [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file explicitly defines the allowed runtimes in its **Dependencies** section. According to the source code, each language serves a distinct pedagogical purpose in the AI engineering pipeline.

### Python for Numerical Computing

**Python** handles numerical work, linear algebra, and tensor operations using libraries such as `numpy` and `torch`. Lessons utilizing Python focus on the mathematical foundations of machine learning while maintaining visibility into the underlying tensor manipulations.

Example from [`phases/01-intro/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-intro/code/main.py):

```python

# AI Engineering from Scratch – Python example

# Source: phases/01-intro/docs/en.md

print("Hello, AI Engineering!")

```

### TypeScript for Web-Focused Lessons

**TypeScript** powers the web-focused lessons and the site-generation pipeline using libraries like `hono`, `zod`, and `ws`. This language demonstrates how AI models interface with modern web technologies and deployment patterns.

Example from [`phases/01-intro/code/main.ts`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-intro/code/main.ts):

```typescript
// AI Engineering from Scratch – TypeScript example
// Source: phases/01-intro/docs/en.md
console.log("Hello, AI Engineering!");

```

### Rust for Low-Level Algorithmic Demos

**Rust** provides a pure standard library implementation for low-level algorithmic demos. This constraint ensures learners understand memory management and performance characteristics at the systems level without external crate dependencies.

Example from [`phases/01-intro/code/main.rs`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-intro/code/main.rs):

```rust
// AI Engineering from Scratch – Rust example
// Source: phases/01-intro/docs/en.md
fn main() {
    println!("Hello, AI Engineering!");
}

```

### Julia for High-Performance Computing

**Julia** supplies a high-performance scientific-computing environment restricted to the standard library only. This language demonstrates how mathematical expressions translate directly to optimized machine code for AI workloads.

Example from `phases/01-intro/code/main.jl`:

```julia

# AI Engineering from Scratch – Julia example

# Source: phases/01-intro/docs/en.md

println("Hello, AI Engineering!")

```

## Standard-Library-First Architecture

The project adheres to a **standard-library-first** philosophy explicitly documented in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md). This constraint prevents "black-box framework magic" by requiring algorithmic implementations to use only built-in language features where specified.

The Dependencies table in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) states:

> "Dependencies … Python … TypeScript … Rust … Julia … Stdlib‑first."

This restriction ensures that every lesson contains visible mathematical operations rather than hidden framework calls. When learners examine the source code in `phases/01-intro/code/` or subsequent lesson directories, they see the raw algorithmic steps required for AI engineering.

## Lesson Structure and Testing

Every lesson in the curriculum contains a runnable `main.<ext>` file in one of the four core languages. These files follow a strict four-to-six line header comment convention referencing the source documentation path.

The file organization follows this pattern:

- [`phases/01-intro/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-intro/code/main.py)
- [`phases/01-intro/code/main.ts`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-intro/code/main.ts)
- [`phases/01-intro/code/main.rs`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/01-intro/code/main.rs)
- `phases/01-intro/code/main.jl`

Each language uses its native test runner for validation:

- **Python**: `python -m unittest`
- **TypeScript**: `npx tsx --test`
- **Rust**: `cargo test`
- **Julia**: Built-in testing framework

This systematic approach ensures that implementations across the core languages for the AI Engineering from Scratch project remain consistent and testable without external dependencies.

## Summary

- The AI Engineering from Scratch project uses four core languages: **Python**, **TypeScript**, **Rust**, and **Julia**.
- The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file authoritatively defines these languages in the Dependencies table.
- A **standard-library-first** policy prevents framework abstraction, exposing raw algorithmic logic in lessons.
- Every lesson includes a `main.<ext>` file following strict header comment conventions that cite the source documentation.
- Native test runners validate implementations for each respective language.

## Frequently Asked Questions

### Does the project allow external frameworks like PyTorch or TensorFlow?

No. While Python lessons utilize `numpy` and `torch` for tensor operations as specified in the curriculum table, the overall architecture enforces a strict stdlib-first policy for core algorithmic demos. The focus remains on implementing mathematical foundations directly rather than importing high-level framework abstractions.

### Why does the curriculum include TypeScript for AI engineering?

TypeScript powers the web-focused lessons and site-generation pipeline, demonstrating how AI models interface with web technologies. The repository uses `hono`, `zod`, and `ws` to teach deployment patterns while maintaining the stdlib-first constraint for fundamental algorithmic code.

### How are the core languages tested in the repository?

Each language uses its native testing mechanism. Python implementations run with `python -m unittest`, TypeScript with `npx tsx --test`, Rust with `cargo test`, and Julia with its built-in testing framework. This ensures compatibility without requiring external test harnesses.

### Where are the core languages defined in the source code?

The authoritative definition appears in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) under the Dependencies table. While the repository contains a [`languages.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/languages.json) file, that resource tracks human languages for site translation rather than programming languages. Practical implementations reside in lesson directories like `phases/01-intro/code/` where each `main.*` file demonstrates the required structure for its respective runtime.