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 star
4 star
3 star
2 star
1 star
Alexandre Canova
Alexandre Canova
"Comprehensive PlayStation 1 Programming with MIPS Assembly & C! Gustavo once again delivers high-quality material that you can't find elsewhere. The course covers everything from the ground up, with MIPS assembly to C, in a structured, easy-to-follow process. Although not mentioned, the course is compatible with Linux and the PSX.dev VSCode extension, in addition to Windows and Mac OS. The course culminates in an ambitious project that recreates the basics of the classic Wipeout game, with Gustavo even going the extra mile to create original music. Future content could benefit from bigger fonts and a black background for easier mobile viewing."
09 Jul 2024
Lucas Samuel Vieira
"A masterpiece! Thank you so much for this course, Gustavo. I am very happy to have finished this course, not only for the sense of achievement, but I feel like I gained a lot from this. It took me quite a while to finish, but there is just so much ground to cover in so little time, and I think that it gave me a dose of reality in terms of how beautiful, powerful delicate and limited the PlayStation was. Made me think of how important it is to squeeze every bit of performance from it, in clever ways. This is the first course I enrolled here, and I am very impressed and happy for learning so much. I think I'm ready to experiment a bit further with the PlayStation now."
09 Jul 2024
Mathew Upchurch
Full Stack Developer
"Great course! Lots of fun... well and lots to learn!!"
05 Jul 2024
"He Did It Again! All my gratitude and respect for Professor Gustavo. Not only can you clearly see his mastery of the content, but he also enjoys it and he is having a good time sharing his knowledge. I have enjoyed all of his courses!"
27 Jun 2024
"The best way to learn to make games for the Playstation 1!! Gustavo is the best cs sensei I've ever had fr fr"
09 May 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.