For simple models (constant incoming radiance), you can indeed just add the optical depths from the different fog 'layers'. (90% sure but the maths is easy to check anyway, see https://forwardscattering.org/post/72)

Coincidentally I just posted a blog post on fog rendering, in particular with exponential height fog, yesterday: https://forwardscattering.org/post/72

Use a multithreaded blocking approach. Much nicer than async.

Substrata: open-source metaverse: https://substrata.info/

They could be if models were trained properly, with more carefully delineated prompts.

I'd be super interested in more information on this! Do you mean abandoning unsupervised learning completely?

Prompt Injection seems to me to be a fundamental problem in the sense that data and instructions are in the same stream and there's no clear/simple way to differentiate between the two at runtime.

I haven't thought about it deeply. But I guess it's about allowing the model to easily distinguish the prompt from the conversation. Models seem to get confused with escaping, which is fair enough, escaping is very confusing. It's true that for the transformer architecture the prompt and conversation are in the same stream. However you could do something like activate a special input neuron only for prompt input. Or have the prompt a fixed size (e.g. a fixed prefix size). And then do a bunch of adversarial training to punish the model when it confuses the prompt and conversation :)

"look, I'm sorry, but the rule is simple: if you made something 2x faster, you might have done something smart if you made something 100x faster, you definitely just stopped doing something stupid"

https://x.com/rygorous/status/1271296834439282690

I use webassembly for Substrata (https://substrata.info/). It works pretty well, allows building a c++ app using OpenGL for the web.

When you have done enough C++ you don't need to fire up compiler explorer, you just use local variables to avoid aliasing pessimisations.

I also wrote about this a while ago: https://forwardscattering.org/post/51

I think this might not be a shortcoming of MSVC but rather a deliberate design decision. It seems likely that MSVC is failing to apply strict aliasing, but that it's deliberately avoiding it, probably for compatibility reasons with code that wasn't/isn't written to spec. And frankly it can be very onerous to write code that is 100% correct per the standard when dealing with e.g. memory-mapped files; I'm struggling to recall seeing a single case of this.

AFIK MSVC has never implemented TBAA by design.

TBAA = type-based alias analysis

I find this distasteful:

  cities  = %w[ London
              Oslo
              Paris
              Amsterdam
              Berlin ]

Do it properly with quotes you lazy people :)

EDIT: typical ruby (on rails) code: saves a few characters, breaks readily (Hint: consider "New Orleans")

Relative to what? Relative to modern OpenGL with good driver support, not much probably. The big win is due to the simplified API, which is helpful for application developers and also driver writers.