Rendering a scene is a function that takes lights, camera, geometry, textures as inputs and outputs an image.

This function is very complex and hard to invert. But, and this is the interesting thing I got from the article, it is similar enough to deep learning functions that the same strategy works: We can take gradients of it and optimize the inputs to fit the target output.

So, while we can't compute the 3D model that would generate the target picture directly. We can ask it "How do we nudge the model to make it more similar to what we want?". If we keep nudging it, eventually it will be very similar. The tool will find the exact position of the lights, the textures, model, etc.

A differentiable renderer can efficiently answer the question "If I tweaked this input parameter (e.g. camera position, object color, light direction) then which output pixels on screen would change, and by how much?" With this information you can run an optimization algorithm to repeatedly tweak the input parameters in the right direction to make the output pixels look more like a target that you want, e.g. a photograph.

Even better, using the chain rule you can connect the differentiable renderer to other differentiable things, like a neural network controller for a simulated robot. Then you can ask e.g. "If I tweaked the robot's arm position, which camera pixels would change?" This would allow you to, given an image of a target configuration (e.g. two stacked blocks), optimize the neural network to produce that image by controlling the robot (e.g. by stacking the blocks).

I think it's doing this: https://en.wikipedia.org/wiki/Gradient-domain_image_processi...?