# How to Run Lesson Code Locally for Python, TypeScript, Rust, and Julia in AI Engineering From Scratch

> Learn to run lesson code locally for Python, TypeScript, Rust, and Julia in AI Engineering From Scratch. Follow simple steps to execute code from the rohitg00/ai-engineering-from-scratch repository.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: how-to-guide
- Published: 2026-06-20

---

**Clone the repository, navigate to any lesson's `code/` directory, and execute the entry file using the language-specific workflow—Python files run directly with Python 3.10+, TypeScript requires Node 20 and `npm run start`, Rust compiles with `rustc`, and Julia runs via the `julia` interpreter.**

The AI Engineering From Scratch curriculum by rohitg00 organizes lessons into self-contained directories under `phases/<phase-number>-<phase-name>/<lesson-number>-<lesson-slug>/code/`. Each lesson ships with runnable implementations in one or more supported languages, following a **minimal-dependency policy** that keeps implementations free of heavy AI libraries unless explicitly marked with a `# requires:` comment.

## Understanding the Repository Structure

Every lesson follows a uniform folder layout that makes it trivial to locate entry points. The repository structure places language-specific files inside the `code/` directory at the lesson level, with subdirectories like `ts/` for TypeScript when multiple implementations coexist. According to the source code organization, this standardization allows the [`scripts/lesson_run.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/lesson_run.py)helper to batch-check Python files across the entire curriculum without requiring manual navigation.

## Running Python Lessons

Python lessons require **Python 3.10 or higher** and run as pure-Python scripts unless external dependencies are specified. The typical entry file is named descriptively (e.g., [`vectors.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/vectors.py)) and lives directly in the `code/` folder.

### Basic Execution

Navigate to the lesson directory and invoke the file directly:

```bash
git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
python3 phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

```

### Batch Syntax Checking

The repository provides a batch runner at [`scripts/lesson_run.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/lesson_run.py) to validate the entire curriculum without executing heavy dependencies:

```bash

# Syntax-only check for all Python lessons

python3 scripts/lesson_run.py

# Execute each entry file (skips lessons with heavy dependencies unless forced)

python3 scripts/lesson_run.py --execute

```

The script uses `py_compile` to verify syntax and enforces a 10-second timeout when running files.

## Running TypeScript Lessons

TypeScript lessons require **Node.js 20 or higher** and assume a self-contained project structure within `code/ts/`. The only recurring runtime dependency is `zod` for validation in select lessons, with `tsx` handling execution.

### Setup and Execution

From the lesson directory, install dependencies and run the start script:

```bash
cd phases/19-capstone-projects/01-terminal-native-coding-agent/code/ts
npm install
npm run start

```

The [`package.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/package.json) defines the `start` script as `tsx src/index.ts`, which compiles and runs the entry point. Most lessons also include a `test` script for validation:

```bash
npm run test

```

The entry point for TypeScript lessons is typically [`src/index.ts`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/src/index.ts), as seen in [`phases/19-capstone-projects/01-terminal-native-coding-agent/code/ts/src/index.ts`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/01-terminal-native-coding-agent/code/ts/src/index.ts).

## Running Rust Lessons

Rust lessons are implemented as **single-file programs** that do not require Cargo projects. You need **Rust 1.70 or higher** (`rustc`).

### Compilation and Execution

Compile the source file with optimization and run the resulting binary:

```bash
cd phases/10-llms-from-scratch/01-tokenizers/code
rustc bpe.rs -O -o bpe
./bpe

```

The [`bpe.rs`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/bpe.rs) file in `phases/10-llms-from-scratch/01-tokenizers/code/` demonstrates the BPE tokenizer implementation. Each Rust lesson includes compilation commands in its implicit documentation derived from the folder layout.

## Running Julia Lessons

Julia lessons require **Julia 1.9 or higher** and execute as single-file scripts using only the standard library or approved packages like `Random` and `Statistics`.

### Direct Execution

Launch the lesson file directly from the `code/` directory:

```bash
cd phases/07-transformers-deep-dive/01-why-transformers/code
julia main.jl

```

The `main.jl` file in `phases/07-transformers-deep-dive/01-why-transformers/code/` serves as the entry point for transformer architecture explorations.

## Summary

- **Python**: Run individual files with `python3` or batch-check with [`scripts/lesson_run.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/lesson_run.py); requires Python 3.10+.
- **TypeScript**: Use `npm install` and `npm run start` inside `code/ts/` directories; requires Node 20.
- **Rust**: Compile single files with `rustc -O` and execute the binary; requires Rust 1.70+.
- **Julia**: Launch scripts directly with `julia` command; requires Julia 1.9+.
- **Dependencies**: All lessons follow a "stdlib-first" policy; heavy dependencies are marked with `# requires:` comments and skipped by default in batch operations.

## Frequently Asked Questions

### Do I need to install machine learning libraries like PyTorch or TensorFlow to run the lessons?

No. The curriculum follows a "stdlib-first" policy where lessons are deliberately self-contained. Only lessons marked with a `# requires:` comment depend on external packages, and the [`scripts/lesson_run.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/lesson_run.py) batch runner skips these unless you explicitly invoke the `--execute` flag.

### Can I run the code without cloning the entire repository?

While you can copy individual files, the repository structure at `rohitg00/ai-engineering-from-scratch` is designed to work as a whole. Relative paths and the [`scripts/lesson_run.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/lesson_run.py) utility expect the full directory tree under `phases/` to be present. Cloning ensures you have the correct context for imports and helper scripts.

### How do I know which dependencies are required for a specific lesson?

Check the file for a `# requires:` comment at the top. Python lessons without this comment are pure-Python. TypeScript lessons list dependencies in their local [`package.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/package.json). Rust and Julia lessons typically use only the standard library unless explicitly stated in comments or README files within the lesson directory.

### Is there a way to verify all lessons compile without running them?

Yes. For Python, use `python3 scripts/lesson_run.py` without the `--execute` flag to perform syntax checking across the entire curriculum using `py_compile`. For Rust, you can compile with `rustc` without executing the output. TypeScript and Julia do not have official batch syntax checkers in this repository, but individual files can be checked with `tsc --noEmit` or `julia --compile=min` respectively.