It’s insane to write another backend, but Walter is doing it anyway. The D compilers come in three variants: GDC (based on GCC), LDC (based on LLVM), and DMD (based on Digital Mars C/C++). Walter implemented code generators for 8086, 386, 486, Pentium, Pentium Pro, and x86_64 because he had to to get a working compiler. The GDC and LDC D compilers already support the AArch64, so why write another? If you’re on the spectrum, this presentation is for you!

D is a general purpose programming language capable of building any type of software—from scripts to highly concurrent low-latency applications. Over the past year, Mike has put D to the test, developing all of his software from scripts, to web, to graphics in the D programming language. In this talk, he will discuss why he is ‘All in on DLang’, and why he is investing his time in D, which he believes makes him more competitive and a better engineer building better software.

In the talk, Mike will show a variety of software projects developed in the last year including: web 2.0, scripting, and even heavy-duty graphics rendering and game engine development for teaching. Audience members will leave with some inspiration, anecdotes of how he overcame various engineering challenges, and the motivation for why he thinks D should also be their primary programming language.

How does D hold up in the demanding field of game programming? Frustrated with using C++ in the AAA industry, and faced with the rare opportunity to start from scratch (and no one to sanity check his opinionated technical ideas) Lewis built a 3D game and engine in D. And a kind of complicated one at that.

Lewis will explore, and if the stars align, demo live:

• DLL-based code hotswapping without limiting yourself to betterC
• How D's introspection lets you view and edit your entire game state live with 300 lines of code
• How to render 150 nested mirrors on screen at once and still hit 60fps
• Where D thrived in supporting the game, and where it could improve
• And much more

At DConf ’24 we introduced our vision for Phobos 3. Since then, we’ve been quietly working on the modules that will form the foundation of Phobos 3 and preparing to increase the scope and pace of development. But did you know that there are Phobos 3 modules you can use today? Perhaps you’re wondering where are we on Ranges. And the question that is on everybody’s mind: How are we going to handle @nogc and nothrow? This has been one of the most hotly debated topics in the community, so this talk will dive into our plan to address this vexing question.

A new version of D’s standard library, Phobos, is currently in development to correct some of the mistakes that have been made over the years which we’ve been unable to fix without breaking code. Part of that effort involves porting over and improving the various metaprogramming facilities in Phobos v2—chief among these being what’s found in std.traits and std.meta. This talk will discuss some of the design decisions involved in that process and go over some of the lessons learned and some things that the language would ideally do better than it currently does with type introspection. Various concepts related to type introspection and metaprogramming in D will be explained and explored.

What would you do in the unlikely event you had to optimize dozens of interrelated audio constants so that your app sounds as good as possible? Well, that would involve a whole lot of hearing. In other words: evaluation of candidate solutions. But evaluating is tiring, so we could instead leverage UDAs and objective measures (Uses AI! Written in Rust!) to evolve source code with the gradient descent, using source code as state. We’ll discover the issues that will emerge once you optimize such program constants automatically.

There’s no shortage of enhancement requests and DIPs, but most of them don’t get realized. Walter Bright jokingly calls himself ‘Dr. No’ because he has to say ‘no’ to so many proposals. This is not a way to make friends. Why can’t he be ‘Yes Man’ instead and live happily ever after?

As someone who has been using D and working on DMD for quite some time now, Dennis finds himself arguing against new features more and more as well. To explain this perspective, he’ll talk about technical debt in the compiler using examples of actual bugs he has fixed, and show you first hand why that small feature we can easily add is actually a huge maintenance burden.

For a couple of years, the DLF team has been having regular meetings to organize and prioritize tasks. As a consequence, priority projects have been identified and work on them has gotten underway. This talk will present those projects, the progress achieved so far, and the next steps forward.

This talk is a deep dive into D’s compile-time introspection capabilities and limitations. Timon will also give an experience report of his (by now, decade-old) foray into attempting to improve the situation in his experimental custom compiler front end for D.

Hipreme Engine and Redub are two projects that point towards a single goal: to make development easier, faster and inclusive. This talk explores how performance, scalability, and real-world usability shaped their design and how D made it all possible.

We skipped it in 2024, but the Ask Us Anything is back! This is your chance to directly ask Walter and Átila your burning questions about the D language. Why did they make that decision you disagree with? What's the backstory behind a language feature? What are they working on behind the scenes? What do they think about your biggest pet peeve or most desired language feature? The floor will be open for an hour or more to everyone in the room, the livestream chat, and the community Discord. Don't be shy!

Declarative programming is a powerful paradigm for writing succinct and ‘correct by inspection’ code. By delegating the ‘how’ to a library implementation, programmers only need to specify ‘what’ they want accomplished. Ben will share two projects where he has used this approach for working with complex data formats: the first a parser/editor for the .mov multimedia container format, the second a PEG-inspired recursive descent parser generator.

The .mov file format is a binary format for multimedia files. Since it uses big endian encoding of integers and can contain variably sized arrays, it is not amenable to a simple ‘mmap and cast’ approach to decoding. The format consists of many different atom types which can contain primitives, arrays, or other atoms. With opDispatch and a little bit of metaprogramming, atoms can be described as normal D structs whose contents are basically copied verbatim from the format spec. The library abstracts format and layout differences and allows access to the binary file as if it were made up of normal D struct objects.

The second project is a recursive descent parser inspired by the pegged library. Pegged is a convenient tool for writing grammars, however, its parser returns a generic parse tree result which must be traversed to convert to domain specific types. For example, in a compiler we'd write a traversal to convert the pegged parse tree to an AST. Ben's library autoparsed instead has users annotate their domain types with their syntax and uses D’s metaprogramming capabilities to build a recursive descent parser which returns the desired objects directly.

Got something interesting to tell the D community, but not interested in presenting a full talk? We’ll give you five minutes to tell the world!

Lightning Talks are presentations restricted to five minutes or less. Speakers plug in their laptops and get started immediately. When their time is up, the emcee pulls them off stage and the next speaker gets going. The Lightning Talks session from DConf ‘23 serves as an excellent example of the format. It even included a stand-up comedy routine—a DConf first!

Any DConf attendee can sign up to present a Lightning Talk. We’ll have up to nine slots available this year, and we’ll fill them on a first-come, first-serve basis. Email social@dlang.org anytime before the conference to reserve your spot (after you’ve registered), or let Mike Parker know at any point during the conference prior to the start of the Lightning Talks session.

What is it like to clearly see and directly code architectural concepts? Can software be skillfully maintained over a long period of time without compromising or reducing its quality? Or is it even possible to increase its quality in a controlled manner during its operation while keeping costs low? Can the approach to software testing eventually become obsolete? The elegant idea behind the Arinas platform, a software development concept enabled by the D language ecosystem, seeks to address some of these issues while also enabling engineers to practically grasp higher levels of abstraction, a wider part of the addressable domain, and manage entropy sensibly. Ľudovít invites you to join him on his journey into the realms of efficiently organized software solutions.

How about using beautiful, colorful blocks to create your source code while the entire documentation is simultaneously elaborated by the software? This is what Murilo is trying to create using D. He will create a version of the game ‘Metal Slug’ in front of the audience to demonstrate the power of this new tool.