• ## A Visit to the Sponza Palace’s Atrium

Croatia's must-see tourist destination.
• ## Some News About the 4th Edition of Physically Based Rendering

We have liftoff.
• ## Let’s Stop Calling it “GGX”

A short plea for getting the naming right.
• ## Sampling in Floating Point (2/3): 1D Intervals

A ramble extending Walker's algorithm to sample arbitrary floating-point intervals, later found to be a rederivation of earlier work.
• ## Sampling in Floating Point (1/3): The Unit Interval

Sampling algorithms can be subtle and tricky, as can be computations that are performed using floating-point arithmetic. This post starts a short series on that topic, starting with the fundamentals: generating uniform random samples between zero and one.
• ## Update: Some Analysis of Physically Based Rendering’s Bibliography

Ending a year of suspense, the numbers are finally in for the fourth edition.
• ## Debugging Your Renderer (5/n): Rendering Deterministically

Making a renderer fully deterministic—the same input always giving exactly the same output—has a few tricky corners that were never all addressed in pbrt until the latest version. Achieving that determinism has all sorts of benefits for testing and debugging.
• ## Debugging Your Renderer (4/n): End-to-end tests (or, “why did that image change?”)

Still in the thick of the task of detecting the presence of bugs in a renderer in the first place, this time the focus is on the value of a large suite of test scenes. Soon soon we will turn to what to do about all of these bugs when we find them.
• ## Debugging Your Renderer (3/n): Assertions (and on not sweeping things under the rug)

Some notes on productively detecting bugs when they occur during the course of rendering and a cautionary tale about what can happen when you ignore runtime errors.
• ## Debugging Your Renderer (2/n): Unit Tests

Returning, now with intention, to write up some thoughts about how to effectively debug a renderer.
• ## Swallowing the Elephant (Part 12): A Postscript On Disk Bandwidth

A few concluding notes (this time for real) about the effect of disk bandwidth when preparing to render the Moana Island scene with pbrt-v4.
• ## Swallowing the Elephant (Part 11): Once More Unto The Beach

More attention to pbrt's performance when getting ready to render Disney's Moana Island scene finally gets us somewhere.
• ## Swallowing the Elephant (Part 10): Rendering on the GPU—Finally

After our extended tour through where pbrt-v4 spends its time getting ready to render the Moana Island scene, we finally look at rendering, comparing performance and images from the CPU and GPU rendering paths.
• ## Swallowing the Elephant (Part 9): We Got Instances

More work on performance with pbrt-v4 and the Moana Island scene, this time looking at getting object instances ready for rendering.
• ## Swallowing the Elephant (Part 8): Meet The GPU

Performance when rendering the Moana Island scene using pbrt-v4 on the GPU was surprisingly good at the start. And yet this is the first of three posts on the topic...
• ## Swallowing the Elephant (Part 7): Time To First Pixel

Digging into where all the time goes when parsing the Moana Island scene and getting ready to start rendering it.
• ## Swallowing the Elephant (part 6): Fool me once…

Returning to Disney's Moana island scene with the latest version of pbrt, pbrt-v4. Just like the first time around, performance was not at first impressive.

• ## Looking For A Scene For the Cover of Physically Based Rendering, 4ed

In search of something amazing...
• ## A Few Words from W. H. Auden

Auden delivers, 82 years early.
• ## Some Analysis of Physically Based Rendering’s Bibliography (1-3ed)

Who's who in the bibliography and how that has changed over the first three editions.
• ## An early release of pbrt-v4 and some notes about pbrt-gpu

The code is on github, scenes are available, and now it's just a matter of finishing writing the book...
• ## Debugging Your Renderer: Introduction (part 1 of n)

Debugging a renderer is its own beast, with the gift of bugs manifested visually, sometimes taunting you with millions of correct pixels and just a few that are bogus. I've decided to write up some of the things I've learned about debugging renderers, starting here.
• ## Naming Maxims

Surely the most important thing to be worrying about at the moment.
• ## Accurate Differences of Products with Kahan’s Algorithm

A nifty use of fused multiply add to avoid catastrophic cancellation that makes for my new favorite floating-point trick.
• ## Need for More Speed: Profiling and Optimizing the pbrt Build

An investigation into building pbrt more efficiently, using lessons learned from clang's new -ftime-trace functionality.
• ## San Miguel, IRL

Some history of the San Miguel model, and an update on what the actual spot looks like today.
• ## Visualizing Warping Strategies for Sampling Environment Map Lights

A visual exploration of the differences between how two sample warping algorithms distort uniform samples when sampling environment map light sources.
• ## Adventures in Sampling Points on Triangles (Part 1.5): Reader Mail and Followups

Digging into a few improvements and nits that were pointed out via email as well as an investigation of another possible mapping to the triangle.
• ## Adventures in Sampling Points on Triangles (Part 1)

A new mapping for sampling points on triangles turns out to reduce variance by more than 2 times compared to the traditional approach.
• ## Re-reading An Introduction to Ray Tracing

Another go-round with an old companion.
• ## 1.3 TB of Physically Based Rendering

Three months ago, we put Physically Based Rendering online. Much bandwidth has been consumed since then.
• ## Physically Based Rendering, online

Physically Based Rendering is now available in an online edition--free for everyone to read.
• ## Swallowing the elephant (postscript: reader emails)

A whole bunch of interesting comments and pointers came in via email after I posted the 'Swallowing the Elephant' series. Today, we'll dig into a few of them.
• ## Swallowing the elephant: all the links

Adventures in rendering the Moana island scene with pbrt, collected together for your convenience.
• ## Swallowing the elephant (part 5)

The conclusion of a series of investigations into improving pbrt's efficiency when rendering Disney's Moana island scene, wherein we look at rendering time and discuss potential future work.
• ## Swallowing the elephant (part 4)

Another pass at reducing memory use when rendering Disney's Moana island scene, this time with a future version of pbrt where we are free to make bigger changes than we can with pbrt-v3.
• ## Swallowing the elephant (part 3)

More work on getting pbrt to parse the scene description of Disney's Moana Island scene in a reasonable amount of time, wherein parsing and graphics state management receive some attention.
• ## Swallowing the elephant (part 2)

Ongoing adventures in trying to get pbrt to render Disney's Moana Island scene in a reasonable amount of time and memory.
• ## Swallowing the elephant (part 1)

"Interesting" things almost always come to light when a software system is given input with radically different characteristics than it has seen before. I learned this lesson in spades when digging into pbrt's performance when rendering the island scene from Moana that Disney just released.
• ## CHECK_RARE and making sense of unusual occurrences

A variation on traditional assertions that I've found to be fairly useful.
• ## On to the next thing

A new job at NVIDIA, where I hear there's some rendering going on.
• ## The story of ispc: all the links

Collected together all for your convenience.

• ## The story of ispc: retrospective (part 11)

Experiences with number of complex systems written in ispc, a brief language critique, and an awkward pull request.
• ## The story of ispc: spreading the world and leaving Intel (part 10)

Life as an open source project, going out and talking with academics, and an abrupt realization that it was time to go.
• ## The story of ispc: the open source release and the end of volta (part 9)

Wherein the open source process was rocky and a name was mangled.
• ## The story of ispc: more on optimizations and performance (part 8)

A few details of the language design helped a lot with being able to generate good code. Custom optimization passes helped a lot with avoiding unnecessary gathers and scatters.
• ## The story of ispc: Bringing up AVX and giving something back to LLVM (part 7)

The arrival of AVX on Sandybridge CPUs offered the potential for a doubling of performance. But first, there was the minor matter of getting an AVX backend working.
• ## The story of ispc: first users and modern CPUs coming through (part 6)

Things were working well with early users and bigger programs worked well. Modern CPUs turned out to be pretty good at running SPMD on SIMD, even though they weren't designed for it.
• ## The story of ispc: first benchmark results (part 5)

Wherein for some, the only reasonable explanation was that I must have cheated.
• ## The story of ispc: C’s influence and implementing SPMD on SIMD (part 4)

Lessons learned from C and how they relate to SPMD on SIMD. Also, the difference between a compiler optimization and a program transformation.
• ## The story of ispc: going all in on volta (part 3)

Getting serious about volta (and making sure the project wasn't killed).
• ## The story of ispc: volta is born (part 2)

Wherein I start writing a compiler without a real plan and the results from a little experiment are uncomfortably exciting.
• ## The story of ispc: origins (part 1)

This one time, at Intel, I wrote a compiler...
• ## Rendering in Camera Space(ish)

Wherein choosing the right coordinate system for ray intersection calculations is shown to be important and where the obvious fix has surprising performance implications.
• ## Goodbye to twitter (and all that)

An experiment gone well in redefining my relationship with the internet.