What you'll learn

PSX programming assembly

This course is a deep dive into the world of PlayStation programming! We'll explore the PS1 hardware, understand its sub-components, and learn how to code games using MIPS assembler & the C programming language. We'll also learn how to use a PS1 SDK library paired with a modern development toolchain to be more productive and push fast polygons out of our console.

MIPS assembly language

We are about to enter the 5th generation of 32-bit consoles. This era brings with it many technology milestones, such as the adoption of CPUs based on RISC architecture and a preference for coding using a high-level language instead of writing games using plain assembly. We will start by learning the basics of MIPS assembly and evolve to use a C compiler with a PS1 SDK to develop our final project.

The tools you'll need

The original SDK was designed for Windows/PC, so you can either use the original 16/32-bit libraries on a 32-bit operating system (Windowx XP), or you can use a modern C compiler with Visual Studio Code on a 64-bit operating system (Windows 10/11). Emulating a Windows system on macOS or Linux is also possible!

windows 32-bits

Do I need a real PS1?

Not at all. You can easily run all the exercises and the final project on a PlayStation emulator. At the end, we will burn a CD ISO and test it on a real console, but that's optional.

psx dev tutorial

Is this course for you?

psx game development

This is a self-contained course teaching concepts from the ground up. However, it is expected from students a basic understanding of coding (if-else, loops, functions).

If you like retro programming & want to learn more about the early days of 3D games, then this course is definitely for you!

About the instructor

gustavo pezzi

Gustavo Pezzi is a university lecturer in London, UK. He has won multiple education awards as a teacher and is also the founder of pikuma.com.

Gustavo teaches fundamentals of computer science and mathematics; his academic path includes institutions such as Pittsburg State University, City University of London, and University of Oxford.

teaching certification
higher education academy
pgclt teaching certification
bpp university award

Course content

35 hours total length 35 Chapters Last updated May 2024
  • Motivations & Learning Outcomes
  • How to Take This Course
  • The PS1 in the History of Game Consoles
  • A New Player Enters the Game
  • What is your favorite PS1 Game?
  • PS1 Hardware Overview
  • The MIPS Processor
  • What is ISA?
  • MIPS Memory & Endianness
  • PS1 Memory Map
  • Quiz: PS1 Hardware
  • MIPS & LSI
  • CPU Registers & Load Instructions
  • Store, Add, & Subtract
  • Jump & Branch Instructions
  • MIPS Cheat Sheet
  • Exercise: Our First MIPS Code
  • MIPS Syntax Rules
  • Installing the ARMIPS Assembler
  • Assembling our Code
  • The PSX-EXE File Format
  • Quiz: MIPS Instructions
  • Step-by-Stey Execution
  • Different PlayStation Emulators
  • Fixing Off-by-One Error
  • MIPS Pseudo-Instructions
  • MIPS Pipeline
  • Delay Slots
  • Exercise: Factorial
  • Quiz: MIPS Pipeline
  • Writing a Factorial Subroutine
  • Negative Numbers
  • Sign Extension
  • Logical Instructions
  • Bitshifting Instructions
  • Quiz: Subroutines
  • Examples of CISC & RISC Machines
  • CISC vs. RISC Instructions
  • Quiz: CISC vs. RISC
  • The PS1 Graphics System
  • Drawing Primitives
  • GPU Packets
  • Finding Packet Information
  • Sending Packets to GP1
  • Sending Packets to GP0
  • Clearing the Display Area
  • Quiz: GPU Packets
  • Drawing Flat-Shaded Triangles
  • Drawing Flat-Shaded Quads
  • Drawing Gouraud-Shaded Polygons
  • Flat-Shaded Triangle Subroutine
  • Stack & Stack Pointer
  • Stack Parameters
  • The MIPS ABI
  • Stack & Heap Space
  • Exercise: Drawing Polygons
  • Variables
  • Variable Alignment
  • Vector Alignment
  • Quiz: Memory Alignment
  • Copying Image Data to VRAM
  • Multiplication & Division with Bitshifting
  • 24BPP Display Mode
  • Quiz: Copying Data to VRAM
  • Moving Away from Assembly
  • The Original PS1 SDK Library
  • Installing Tools on Windows 11
  • Installing Tools on Windows XP
  • Compiling a Simple C Project
  • Double-Buffer Screen
  • Integer Data Types
  • Primitive Data Types
  • Ordering Tables
  • Primitive Buffer
  • Sorting Primitives into the OT
  • Sorting a Gouraud Quad in the OT
  • More About Ordering Tables
  • Quiz: Ordering Tables
  • A Review of 3D Projection
  • Vertices & Face Indices
  • The GTE Coprocessor
  • Basic 3D Transformations
  • Quiz: 3D Graphics Review
  • The RotTransPers Function
  • Coding a Rotating 3D Cube
  • Normal Clip
  • Exercise: Cube Faces as Quads
  • Review of Floating-Point Numbers
  • Fixed-Point Number Representation
  • Coding a Bouncing Cube
  • Can I use Floats?
  • Exercise: Drawing the Floor
  • Different Transform Matrix per Object
  • Quiz: Fixed-Point Math
  • GTE Register Set
  • Inline GTE Instructions
  • RTPT vs. RTPS
  • Quiz: Inline GTE Instructions
  • Reading Joypad State
  • LIBETC Joypad Constant Names
  • Reading Joypad via a BIOS Function
  • The PlayStation BIOS
  • Joypad Header File & Implementation
  • Quiz: Joypad Input
  • Header Files & Implementation Files
  • Breaking our Project Apart
  • Header Files for OT Functions
  • Header Files for Display Functions
  • Quiz: Header Files & Implementation Files
  • Camera Space
  • Look-At Transformation
  • Look-At Function
  • Coding the Look-At Camera Model
  • Quiz: Camera Transformation
  • CD-ROM
  • Generating an ISO on Windows XP
  • Generating an ISO on Windows 11
  • A Function to Read Files from the CD
  • CD-ROM Access via a BIOS Function
  • Understanding the MODEL.BIN File
  • Dynamically Allocating Buffers
  • Heap Initialization on Windows 11
  • Interpreting Bytes as Numbers
  • Handling Different Order of Bytes
  • Reading Vertices & Faces from the CD
  • Quiz: CD-ROM Access
  • UV Coordinates, TPAGE, & CLUT
  • Installing TIM Tool
  • TIM File Format
  • Reading TIM File from the CD
  • Textured Cube Faces
  • Wobbly Textures
  • Polygon Jitter
  • TPAGE Limitations & Techniques
  • Quiz: Textured Polygons
  • Introduction to our Final Project
  • Importing Project Assets
  • PRM File Layout
  • Reading Object Name from File
  • Reading Vertices & Normals from File
  • Handling Different Types of Primitives
  • Reading Primitives from File
  • Drawing Flat-Shaded Object Faces
  • Using sizeof with Variable Name
  • Quiz: PRM File Layout
  • CMP File Layout
  • Reading Number of Textures from File
  • Reading TIM Sizes from File
  • A Function to Extract LZSS Data
  • Texture Structs
  • Uploading CMP Textures to VRAM
  • Global Texture Store Array
  • Rendering Textured 3D Objects
  • TSB & CBA
  • Quiz: CMP File Layout
  • Loading Multiple CMP Files
  • Exercise: A Linked List of Objects
  • Linked List Implementation
  • Handling Joypad Press & Release
  • Quiz: Multiple 3D Objects
  • Reading Scene Objects from the CD
  • Camera-Object Distance Check
  • Drawing Scene Objects
  • Track Section & Faces
  • Structs for Section & Faces
  • Reading Vertices, Faces, & Sections
  • Function to Render Track Sections
  • Shrinking Track Vertices
  • Exercise: Testing Face Flags
  • Drawing Quad Lines
  • Bypassing the GTE 16-bit Limitation
  • Claming Overflow Values
  • Loading Track Texture Tiles
  • Manually Position Textures in VRAM
  • Loading Track Faces UV Coords
  • Flip Face Texture
  • Polygon Subdivision
  • Drawing Quads Recursively
  • Subdividing UV Coordinates
  • T-Junctions
  • Minimizing T-Junction Artefacts
  • Ship Struct
  • Ship Header File
  • Review of Movement in Game Physics
  • Thrust Magnitude
  • Frame Rate on NTSC vs. PAL
  • Yaw, Pitch, & Roll
  • Deriving our Rotation Matrix
  • Extrinsic vs. Intrinsic Rotation
  • Exercise: Placing the Camera Behind the Ship
  • Yaw Velocity
  • Roll Left & Right
  • Rethinking Section Rendering
  • Initializing Ship's Nearest Section
  • Update Ship's Nearest Section
  • Rendering Track Ahead
  • Clamping Track Vertices
  • Wipeout VEW Files
  • Audio & SPU
  • Converting WAV to VAG
  • Playing VAG Sound Effects
  • Pitch & Sampling Frequency
  • Background Music
  • Recording an Audio Track
  • PlayStation Games & Jungle Music
  • Burning a Game CD Disk
  • Running our Game on a Real PlayStation
  • Conclusion & Next Steps

How is this course different?

This course tries to be as beginner-friendly as possible. While there are other resources out there on PlayStation development, we'll focus on the basics and try not to skip any important detail as we evolve.

ps1 programming tutorial

Learning how to create games for the original PlayStation is a great excuse to explore really hardcore computer science topics. As we learn different aspects of the 32-bit generation of consoles, we'll touch important concepts like algorithms, data structures, data compression, computer architecture, fixed-point math, computer graphics, and much (much!) more.

Many new games try to imitate the style and the visuals of old PS1 era using a modern game engine. This is no imitation! We'll be flipping bits on the OG PlayStation.

psx programming tutorial

Many people are surprised that the first part of the course uses MIPS assembly. Using an assembler in the early stages of our course allows us to really understand the low-level aspects of the console & really grok how data flow inside the machine.

We'll then move away from assembly and climb one layer of abstraction up; we'll work with a C compiler paired with a PS1 SDK. This is where we'll really glue all the concepts that we learned before to consolidate our knowledge with a final big project.

psxdev tutorial

At the end of the course, you'll have all the tools and the skills you need to grow and evolve on your own. You'll have a working project running on the PlayStation console and a deep understanding of the theory that underpins the development of PS1 games.

73% of our students come back for another course

We don't offer discounts on our courses. Ever.

What students are saying

5.00
5 star
100.0%
4 star
0.0%
3 star
0.0%
2 star
0.0%
1 star
0.0%
Peter Robinson
"This course teaches the valuable background knowledge. I love that Gustavo explains all of the details behind how memory is physically stored. It's great that he covers the reasoning behind the CPU behaviours, and how problems can come up. I love that this course covers not just how to achieve the end product, but it also educates us so we can continue making more."
18 Nov 2024
"Simply the best! Never thought I'd find a course like this about the game console of my childhood. Very detailed and high-quality content. For those interested in this topic, it's 200% worth the money. Thanks Gustavo!"
15 Nov 2024
Daniel Clarke
"I thoroughly enjoyed this course. I found it well-structured, and it moves along at a good pace while digging in deeper when it needs to. Three months after finishing I’m still working away on a ps1 game, which is about the best recommendation I can think of."
07 Nov 2024
"Superb course! Superb course covering the fundamentals of PS1 programming in depth. Highly recommended. I wish there would have been a section about how to bring 3D models from Blender or some other generic 3D modelling package as now after the course spends quite a long time going over 3D formats specific to Wipeout, which is interesting as a computer science topic, but not that useful if you just want to get making your own PS1 games. The first half going through the hardware, MIPS, assembler and low level rendering is flawless though and already worth the time investment to dig into!"
24 Sep 2024
Tero Huttunen
"Excellence! A very substantial course! Aside from all the PS1-specific goodness, the inconsistent endianness, compression, and multiple ways of encoding geometry and textures in the source files helped to get more comfortable with the lower-level data conversions and processing. I had never programmed assembly or C before, but the course was a pleasure to follow along and very educational."
20 Sep 2024

Other similar courses

NES Programming with 6502 Assembly

22 hours
  • Learn 6502 Assembly programming games for the Nintendo Entertainment System.

Atari 2600 Programming with 6502 Assembly

18 hours
  • Learn 6502 Assembly programming and create games for the Atari 2600 console.
raycasting texture c

Raycasting Engine Programming with C

18 hours
  • Write a raycasting engine with textures and sprites using the C programming language.