dylint VS pbrt-v3

There is also https://github.com/trailofbits/dylint for writing custom lints.

Apart from clippy (which uses rustc-internal APIs), there are two other projects which can be used to implement lints: rust-analyzer can be extended with more diagnostics, and dylint provides an interface to run custom lints for Rust.

RE: Program is a model

There are some more advanced refactoring tools now available. These tools enable you to write code to detect bad code patterns and even automatically fix them. You can use them to write one-off transformations of code too. Rust has Dylint [1] and C# has Roslyn Analyzers [2]. Facebook has tooling [3] that helps writing CodeMods, enabling authors to generate changes for thousands of files at a time.

The thing I really would like to see is a smarter CI system. Caching of build outputs, so you don't have to rebuild the world from scratch every time. Distributed execution of tests and compilation, so you are not bottle-necked by one machine. Something that keeps track of which tests are flaky and which are broken on master, so you don't have to diagnose spurious build failures. Something that only runs the test that transitively depend on the code you change. Automatic bisecting of errors to the offending commit.

[1] https://github.com/trailofbits/dylint

[2] https://docs.microsoft.com/visualstudio/code-quality/roslyn-...

[3] one example: https://github.com/facebook/jscodeshift

If you're looking for something like clippy but with custom lints, there's also dylint -- it is clippy, but with support for running dynamically loaded lints across multiple versions of Rust.

You might find dylint useful! It's exactly that: a tool to run custom clippy lints.

Dylint. A tool for running Rust lints from dynamic libraries.

Physically Based Rendering[0] was an excellent textbook when I read it ages ago and conveniently enough it looks to have been updated with a new edition last year.

[0]: https://pbrt.org/

Physically Based Raytracing

Both of these books are free, and both are written in C++, but they can be done in any language. The first book, a raytracer in a weekend, is part of a series, you can find it here: https://raytracing.github.io/ And, if you get to the third book in that series, or you need a reference book, the PBRT book covers the math in more depth and discusses the latest theory, you can get the last edition of the book (5 years out of date) for free though: https://pbrt.org/

Making a “complete” one is a never-ending rabbit hole you can spend a lifetime on and is a very active area of research covering more advanced geometry, probability, optics, machine learning etc etc. A great introduction to that is https://pbrt.org

This isn't the highest priority but if you haven't already, learn how computer graphics works. Get a working knowledge of the camera matrix, real time graphics (say, OpenGL but threeJS is an option), and photorealistic graphics. PBRT is the go-to for photorealistic graphics. The first two books of Foundations of Game Engine Development are way more useful than they have any right to be (and my favorite textbooks I've ever read, 10/10).

Org-mode strength though is in working with different languages in a same source file, which I am not sure if Knuths version does. Anyway, to see how the original idea looks like, check the Wikipedia article, or to see it in real-life see some of books that are written in the literate style, like Physically Based Rendering, which seems to be available for free nowadays or C Interfaces and Implementations.

I contributed a tiny bit to pbrt[1], and one of the things I loved was that if you just plugged in physical values you almost always got great results with minimal tweaking.

The Octane data seems most complete at first glance (with complex IOR etc), but for things like milk and blood I expected at the very least some absorption coefficient for the translucency or similar.

[1]: https://pbrt.org/