You will say that you don't want a GC but in reality the GC can be optimized as much as you wan't, and in the mean time you'll get precious _developement time_ to optimize further.
If you can afford the D runtime by all means take it ; for some products I'm doing without the D runtime, and the surprise was that it did't make things any faster _at all_ without the runtime (we did it for other reasons). The only real gain is memory consumption of GC vs manual and that is achievable without going through extreme coercitive measures like -betterC.
[0] https://p0nce.github.io/d-idioms/#The-impossible-real-time-t...
- std.experimental.allocator
- @nogc to ensure, well, no GC usage
- various things built on placement new (`emplace`)
- GC profiling with -profile=gc, will display number of allocations and size
None of this existed when people were already making high-performance systems with D...
--- A popular example is minecraft that uses mainstream G1 GC.
I was suspicious about #3 since classes in D don't necessarily need the GC. For starters D supports C++ classes, so this works:
https://gist.github.com/atilaneves/b69ed0399efac21bb7a977afd...
I used `scope` with `new` to allocate on the stack, but `emplace` should just work as well to "placement new" a class in malloc'ed memory.
#4 is annoying but one could always use the OS threading API. It's doable to write a library solution to do that akin to boost or Qt before C++11. You do it once and it's there.
#5 No dynamic arrays are also annoying. But... writing a clone of std::vector isn't hard, and there's a unique array in my automem library that _should_ be usable in betterC (but I haven't checked): https://github.com/atilaneves/automem/blob/master/source/aut...
> Another note is that a big thing I'm looking for is massively improved compile times
You get that with D.
Those rely on the garbage collector. If you are willing to do C style memory management, they are all available with betterC.
3, 4, and 5 are all pretty sore points. 2 would be as well if it weren't extremely likely that for any game you create roll some sort of reflection system. It would be a sore spot for small projects.
3 - No access to classes and polymorphism is a bit of a downer. Although I'm a big believer of data-oriented design, I think there are still many cases where modelling things as objects is the best way to go, especially for things like scene actors and game objects.
4 - No built in threading (core.thread) puts a hamper on any sort of distributed updating or performance optimizations you'd want to do. I'd imagine the workaround is external multi-threaded dlls or something, but it sounds like a pain to manage and deal with in a workflow.
5 - No dynamic arrays. This container is used abundantly in game development. It shows up 5 or more times for every heap/stack/queue. This may not be an issue if you want to write a special memory environment and your own containers, which is common in game development, but not having access to a standard one certainly hurts when it comes to smaller projects or graphics programming experiments.
I may be somewhat off base here since what happened is that I read about those being missing and decided not to try it.
Another note is that a big thing I'm looking for is massively improved compile times, which is one of the biggest things Jai looks to have over C++ in addition to its compiler hooks and #run.