8 ms·
Let's learn D game programming development (2021) [video]
- skocznymroczny 4y agoI've been using D for my amateur game engine development for a while now and so far it's been a pretty good experience. Thanks to reflection features I can serialize/deserialize entire scenes just by annotating the fields in structures as needed, and can also autogenerate editor fields for inspector views. With C++ I'd have to do some out of place looking define magic to generate my structures and it wouldn't just work with any struct. Unlike my fellow D game developers I don't fight the GC. I don't use any of the @nogc features in D or obsess about manual memory management. I have a fairly beefy machine, but still, I think the dangers of D's GC are somewhat overblown. There was a blog article back in the day by someone writing a 3D space game in D and it was often referred to as an example of how bad D's GC is, but there wasn't really enough data in that post to know about the methodology. Firstly, in a game most of the data should be preallocated anyway, in the game loop there isn't that much to allocate. Secondly, D has value types, so there's much less pressure on GC because you can stack allocate things like vectors or matrices. Sure, in other GC languages a sufficiently smart VM could probably optimize that out and avoid the GC, but I doubt it would catch most cases. I also like how easy it is to interact with C. This grants me access to gamedev libraries such as bgfx, wgpu-native, ODE, NewtonPhysics and many, many more. C++ interaction however never cared much for. I feel like D spent too much effort here, even adding language features (copy constructors) to interact better with C++. In the meantime, it seems that it's still hard to interact with C++ libraries from D, and ironically I feel like languages like Rust or Zig have a better interop story with popular C++ libraries like Qt or Bullet, despite not investing as heavily into that. My main current issue with D is that as a community project, it seems to lack some direction. There's some very talented people working around the project, but most of that work is done on a specific issues and projects people want to work on. Since a lot of the work on D is unpaid work, you can't force people to do what you want them to do. However, the language lead team should influence the direction of the language and provide a path forward. It's getting better in recent times, so there is a lot to look for in that aspect. The multiparadigm aspect of D and its flexibility can be detrimental too sometimes. There are some subgroups in the language community that approach the language in a specific way and feel their way is the true "D way". For example, you have OOP folks that would like more features like named constructors, you have template metaprogramming folks who would like to remove most D features such as classes and just replace them with some metaprogramming template magic, you have folks that disable the GC and avoid the standard library from the get-go. This causes some friction, because any new feature for the language would have some opposition from the other side who will consider it bloat and unnecessary. In some ways the article about "Lisp curse" applies well to D. These factors however don't really influence me personally, because I get to pick the features I want to use and can avoid the ones that I don't see the benefit of.
- mhh__ 4y agoThere will be a vision statement published as soon as Mike Parker has finished editing it.
- mhh__ 4y agoLDC does a fairly good job of removing brain-dead GC allocations (mainly for closures). As for style, we have very few issues getting non-D programmers writing D. They don't know the fancy stuff exists until we tell them when they need it.
- pjmlp 4y agoThe lack of the direction is definitly the biggest issue, as every couple of years the next big thing that will finally bring the crowds to D gets started, without fully finalizing the previous one. These distractions have allowed competition to come up, and C++, Java and C# to strengthen their position by improving in areas of metaprogramming, modules, type inference and AOT compilation, making the transition to a smaller ecosystem less appealing, just to use such features. I recently noticed that Andrei Alexandrescu is at NVidia now, and I imagine that most likely he will continue focused on C++ instead, or maybe NVidia is going to add D to CUDA? I don't know, it is a pity, because the community is great.
- nicwilson 4y agoShameless plug: LDC (the LLVM based D compiler) can already target CUDA (and OpenCL) and wraps its API and all of the nasty details involved in replicating <<<>>> kernel launches with https://github.com/libmir/dcompute/ https://github.com/libmir/dcompute/ with a sane syntax that's type safe. LLVM handles the codegen, and all of the "magic" is done in the library.
- giancarlostoro 4y agoI think having an OOTB standard library that kind of targets production ready functionalities like Golang does would definitely be the real game changer for me. With Go I can do everything leading up to using a database driver for web dev without installing a single external dependency. I know D has Vibe.d but Go has net/http which is production tier. Don't make me work to build something by forcing me to research every piece of it. You can do all sorts of things in Go out of the box that get you building production tier work right away.
- cassepipe 4y agoI really like D's compiler -betterC flag. D is really nice as a better C.
- nurettin 4y agoIt would be nice if we could use D with C++ libraries like quickfix or IBApi. Then it would be more useful in finance.
- mhh__ 4y agoD has one of the best/most-mature C++-interop stories around. You can't talk to everything but the GCC and LLVM backends rely extensively on D producing correct C++ classes and vtables. You can catch C++ exceptions
- bachmeier 4y agoI don't use it, but C++ interop is explained here: https://dlang.org/spec/cpp_interface.html https://dlang.org/spec/cpp_interface.html
- badsectoracula 4y agoSome months ago i started making a new game engine in Free Pascal[0]. D however was the language i considered the most of all alternatives due to its fast build times (at least for DMD) and metaprogramming and compile time function evaluation and code generation abilities that would help a lot to minimize boilerplate and automate things. In fact i chose FPC less for the language and more for other reasons - as a language i think D would fit better. The two main reasons i chose Free Pascal are (both of which are important): 1. There is a strong aversion to breaking working code in FPC which to some extent is also part of the overall ecosystem. Code i wrote 20 years ago still compiles because any new features are made so that they don't break existing code. Exceptions exist, like when how string are handled changed, but that was a quick fix (in all of my programs i only had to apply a single line fix twice). I don't know D's story on that but i've heard that there were updates to the D compiler that broke code (but i don't know how severe that is - FPC also introduced theoretically breaking code almost every version but in practice it is usually extreme edge cases, compiler bugs or very internal things and these latter only change like per decade or so). In general i want code that i know it worked today to keep working in 10 years from today so i can focus on other things instead of babysitting it (i do copy/paste code i know that works from my existing projects all the time - even the engine i linked above contains a lot of code from older projects, the earliest bits being from 2007 or 2008). This is even more important if i decide to switch to a new language because i wouldn't be able to use much of my existing code so any new code i write i want it to be valid for years ahead. 2. Lazarus and LCL. Think open source Delphi or Visual Basic with a real framework and a strong language. Lazarus is a "real" IDE in that it isn't just a glorified text editor attached to a compiler but it knows the language and builds a database of the entire project in memory, which allows for it to manipulate the code for you (this avoids a lot of boilerplate that come out of the verbose syntax Free Pascal has). More importantly it provides a WYSIWYG visual editor for GUIs (very important for tools) and a rich application framework (LCL) that is designed around Lazarus - these aren't independent bits someone stuck together with some glue, they are all made with each other in mind, which provides a more coherent experience than if someone stitched things together (if anything most of the issues Lazarus/LCL has is from things outside of their control, like the backend GUI toolkits). I have used a lot of other GUI approaches, Lazarus beats them all hands down. And as a cherry on top Lazarus is a native app written in Free Pascal itself and is very responsive - it even runs on older Rasberry Pis with relatively low resource requirements. Sadly D doesn't seem to have a decent GUI story, let alone something like Lazarus and LCL. A promising library was dlangui[1], but that is a 3rd party library that looks like the author decided to abandon[2]. Honestly IMO without something that is adopted by the core D developers (and by extension the rest of the D community) i can't see anything flourishing there - it'll instead be a bunch of independent solo devs making their own half-baked stuff for eternity (btw, yes, Lazarus/LCL are technically a separate project but in practice there is strong overlap between the two projects' developers and they share resources). At best you get bindings to Gtk+ but that has its own share of issues and bindings to other toolkits (e.g. wxWidgets) look abandoned. I occasionally check out D to see what is the status wrt the above but for years things do not seem to change. I do hope that at some point D will have a good GUI application framework and a good native IDE that understands the language itself. [0] https://i.imgur.com/1Y5hL26.png https://i.imgur.com/1Y5hL26.png [1] https://github.com/buggins/dlangui https://github.com/buggins/dlangui [2] https://github.com/buggins/dlangui/issues/608 https://github.com/buggins/dlangui/issues/608
- squarefoot 4y agoWhat is its level of maturity on non x86 platforms such as ARM? It might be a nice alternative to C and especially C++ on small embedded boards, but then any smaller overhead would matter a lot more than on a PC.
- destructionator 4y agoFully operational. On arm/linux it is trivially easy to use, tends to just work out of the box (ldc offers packaged downloads on their website, gdc is in the Raspbian repository, etc). If you are doing bare metal and/or strictly limited hardware resources it is a little more work to be productive with minimal runtime but still not hard if you're familiar with how to do it.
- olvy0 4y agoI learned D and then solved Advent Of Code 2019 with it. Like other people above, I really liked the language, and I wish could use it at work. For me it hit a good spot midway between C# and C++. The documentation was complete enough for me. Although IMO AOC isn't representative of "real world" programming. Regarding the GC, I had no major problems with it, but when faced with frequent allocations it performed slightly worse than what I'm used to from C#, in terms of memory consumption. In C# code, in places where I'm not concerned with performance, I'm used to allocate many small and temporary dictionaries freely without a hitch, the dotnet GC does a great job of releasing them as I go along. In D however I wrote code using the same style (allocating relatively small temporary dictionaries in a loop) and saw memory usage ballooning very quickly, to several GBs. At the end the intended solution for the AOC problem shouldn't have involved this many allocations anyway, so I didn't spend time investigating this too deeply. Small dynamic arrays did not cause this problem, though, as far as I remember, the GC seemed to collect them well enough.
- schveiguy 4y agoI learned how to use raylib from this youtube series, and used it to teach some homeschool kids D programming. Very nice series!
- chromatin 4y agoI absolutely adore D and have used it for years, including publishing software. However, the community is just too small (which has several consequences, including lack of packages, web frameworks, etc.), and for serious projects that I want to move to commercialization, I had to move to Rust.
- VHRanger 4y agoI love D. I just wish it had more popular traction - it's much better to program in than Rust, Go or even C# as a language, but the community support is lacking.
- yrgulation 4y agoCame here to say exactly that. And despite my comment’s redundancy i’ll say it again. I love this language. Straight to the point, easy to learn, read and write. I wish it gained more traction.
- MrVandemar 4y agoI'm in the market for a new compiled language. Rust seems obstuse. I was toying with picking up Go but haven't committed yet. I want to write a Roguelike. I'm here and listening to you. Sell me on it.
- p0nce 4y agoThe BindBC family of libraries gives you dynamic & static linking to many game libraries: https://code.dlang.org/search?q=bindbc https://code.dlang.org/search?q=bindbc You can start your D usage with these examples: https://github.com/p0nce/DIID https://github.com/p0nce/DIID I don't know the status of https://code.dlang.org/packages/libtcod-d https://code.dlang.org/packages/libtcod-d
- pwdisswordfish0 4y agoDart is also an option. https://github.com/munificent/hauberk https://github.com/munificent/hauberk https://journal.stuffwithstuff.com/category/roguelike/ https://journal.stuffwithstuff.com/category/roguelike/
- pizza234 4y agoIn game communities, there are lots of developers who spend time inquiring and researching about game writing platforms (languages, libraries, engines) but end up writing nothing. So a developer expecting somebody to "sell" them a language in order to write a game, will likely end up writing nothing. "Rust seems obstuse" doesn't mean anything. On the other hand, I personally think that Rust is not the most productive language, overall, for game development (I'm familiar with Rust gamedev). This consideration includes the hard truth that as of now, the game libraries are young and buggy. In an theoretical world, where all the languages have stable and equally functional game libraries/engines, in my opinion, the most productive language is something with deterministic (manual) memory management, but less memory safety (=overhead) than Rust, but that is still safer than C-family languages. I can picture D fitting this characteristics, but also other modern languages. This does not apply to areas where where safety is paramount (e.g. networking).