Apple officially deprecated GL/GLES on both MacOS and iOS 7 years ago, and only ever supported up to GL 4.1 (which came out in 2010), meaning it doesn't support essential "modern" features like compute shaders (DX11 had them in 2009), or bindless textures (supported since 2012 on AMD+Nvidia, and 2015 for Intel iGPUs, massive performance win, needed for GPU driven rendering and ray tracing).

Right, and the damage Apple has done to themselves with this policy is several orders of magnitude higher than OpenGL users have suffered from not being able to use OpenGL on Mac or iOS. Apple gets: No indie games that aren't sluggish Unity or Unreal asset flips. OpenGL devs get: Now you need to pay a specialist a few $x,xxx to port your game to iOS if you ever get popular enough that you want your game on the Apple ecosystem.

Apple did that to push people towards their own walled garden of APIs rather than some deficiency of the OpenGL API.

There is no "technical" solution to this, no Even better API that would make them support it, as it's a business decision as much as anything else.

No need to transcode to HLSL, DXC already accepts SPIR-V input (and both Chrome and FF are shipping DXC).

E-CVTs are extremely reliable and are different from CVTs (CVTs use a belt attached to 2 cones, E-CVTs are just a single planetary gear set), but a lot of car guys and even some mechanics don't realize they're completely different.

Gas car sales peaked in 2018 globally. EVs are already >20% of new car sales worldwide, and the US is a joke when it comes to EV sales compared to Europe or China.

https://ourworldindata.org/electric-car-sales

Part of the rust dependency issue is that the compiler only multithreads at the crate level currently (slowly being improved on nightly, but there's still some bugs before they can roll out the parallel compiler), so most libraries split themselves up into a ton of small crates because otherwise they just take too long to compile.

edit: Also, `cargo-vet` is useful for distributed auditing of crates. There's also `cargo-crev`, but afaik it doesn't have buy in from the megacorps like cargo-vet and last I checked didn't have as many/as consistent reviews.

https://github.com/mozilla/cargo-vet

https://github.com/crev-dev/cargo-crev

Can't believe I'd never heard of cargo vet before, that sounds really promising!

> so most libraries split themselves up into a ton of small crates because otherwise they just take too long to compile.

In practice, does this make it feasible to pick and choose the pieces you actually need?

It can do. Additionally, because each part is now smaller it's now easier to ensure that each part, in isolation, does what it says on the tin. It also means that other projects can reuse the parts. An example of the last point would be the Regex crate.

Regex is split into subcrates, one of which is regex-syntax: the parser. But that crate is also a dependency of over 150 other crates, including lalrpop, proptest, treesitter, and polars. So other projects have benefited from Regex being split up.

Yes, when done properly. Rust has "feature flags" that can selectively enable dependencies, and effectively act as `#ifdef` guards in the code.

The core unity game engine is c++ that you can't access, but all unity games are written in c#.

And you could do that with any garbage collected language, right? You could reuse that C++ core with a JVM language.

Linux on arm is actually pretty terrible outside of the server space due to their (Qualcomm, Imagination, and ARM) integrated GPUs being bad and having terrible drivers.

Qualcomm doesn't belong in the list, Freedreno and Turnip are feature complete open source GPU drivers.

R5s has a garbage CPU that won't be able to handle QoS on probably >250mbps.

I'd avoid anything arm based that doesn't have a7x cores (ideally a76/a78 or newer, though I don't think there's any SBC socs using the a710/715/720 yet). A55 cores are old stupidly slow efficiency cores (area efficient, not power efficient).

Hell, modern audio codecs (opus and AAC, but not the ffmpeg opus/AAC encoders) are transparent at ~160-192k. MP3 is a legacy codec these days, and generally needs ~30% more bitrate for similar quality.