Raytracing in Rust

Overview#

On June 1st, 2025, I was bored and ran out of ideas for things to do on a Sunday. I remembered my friend telling me about a project he did where he implemented ray tracing following an online book. I don’t know why or how I remembered that. I immediately message him to get the link to the book.

The Book: Ray Tracing in One Weekend

The book is in C++. I thought it would be a good challenge to implement it in Rust. and maybe improve my Rust knowledge along the way.

I am not sure if I will be able to pull it off in a single weekend. but I am going to keep at it without a deadline of some sort. I aim to simply finish the implementation in Rust.

As part of the learning, I will be collecting a lot of useful resources. I am going to link all of them in the resources section here.

Just realized from the GitHub link for the book that this is a series of books. https://github.com/RayTracing/raytracing.github.io/

Let’s see if we can follow along for The Rest of Your Life.

Resources#

With that out of the way, lets start our first Milestone.

Output an Image#

The Goal of this chapter is to create a image file with colour information for each pixel randomly generated by our function. sounds complicated but in reality its very simple.

First lets setup the initial height and width of the image.

1
const IMAGE_WIDTH: u32 = 256;
2
const IMAGE_HEIGHT: u32 = 256;

u32 here refers to the dataType, we are dealing with 32 bit integer here. the letter u denotes that this is a unsigned integer. which simply means that we will not require negative values in this variable. if we require negative values in a variable then it should be declared as asigned variable i32

According to the book we were supposed to write the pixel data into a ppm file. which is a awful image format. I am going to try and write png image. unlike C++ we have a rich developer eco system with packages (crates) that we can use to write a image file. I am going to use the crate Image for our use case.

The final code looks this:

1
use image::{ImageBuffer, Rgb, RgbImage};
2

3
fn main() {
4
    const IMAGE_WIDTH: u32 = 256;
5
    const IMAGE_HEIGHT: u32 = 256;
6
    // create a pixel map for given image witdht and height
7
    let mut buffer: RgbImage = ImageBuffer::new(IMAGE_WIDTH, IMAGE_HEIGHT);
8

9
    // Iterate over the coordinates and pixels of the image
10
    for (x, y, pixel) in buffer.enumerate_pixels_mut() {
11
        let r = x as f64 / (IMAGE_WIDTH - 1) as f64;
12
        let g = y as f64 / (IMAGE_HEIGHT - 1) as f64;
13
        let b = 0.25;
14

15
        let ir = (255.999 * r) as u8;
16
        let ig = (255.999 * g) as u8;
17
        let ib = (255.999 * b) as u8;
18

19
        *pixel = Rgb([ir, ig, ib]);
20
    }
21
    // create a std output stream with pixle information to write to file.
22
    buffer.save("image.png").unwrap();
23
    // create a file.
24
}

When run this code, it will generate a 256x256 png image with a colour gradient.

1
match buffer.save("image.png") {
2
    Err(e) => eprintln!("Error writing file: {}", e),
3
    Ok(()) => println!("Done."),
4
};