September 17–20, 2024

Symmetry Investments and the D Language Foundation are thrilled to invite you to the D Programming Language Conference 2024 in London, from September 17–20. With help once more from our friends at Brightspace Events, we’re excited to return to our favorite venue, CodeNode.

DConf is more than a conference; it’s a community celebration. It’s where DLang enthusiasts and experts from across the globe converge for four days of knowledge sharing, collaboration, and fun. Though our regular online meetups are valuable, they can’t replicate the connection and energy of in-person interactions, be it during engaging sessions, casual chats, or our nightly BeerConf.

Whether you’re a seasoned DConf veteran or joining us for the first time, we can’t wait to welcome you to London!

Keynote Speakers

Walter Bright
Creator and Co-maintainer of the D Programming Language

Robert Schadek
Programmer at Symmetry Investments and D Core Team Member

Timon Gehr
Researcher at ETH Zürich and D Core Team Member


Notably absent from the schedule this year is the Ask Us Anything session, a DConf tradition. We decided to drop it this year in order to make room for an additional talk. However, we aren’t dispensing with it entirely. We’ll be hosting an online AUA live stream at some point close to the DConf dates. We’ll update the schedule with the information once it’s sorted, so stay tuned!

Click [Show Details] next to a speaker’s name below for information about a talk, panel, or speaker.

Note that all times are in UTC + 1.

  • Tuesday September 17th

  • 08:00 Breakfast Snacks
  • 08:55 Introduction
  • 09:00 Day One Keynote
    by Walter Bright
    Duration: 45 Minutes


    Walter Bright is the creator and first implementer of the D programming language and has implemented compilers for several other languages. He’s an expert in all areas of compiler technology, including front ends, optimizers, code generation, interpreter engines, and runtime libraries. Walter regularly writes articles about compilers and programming, is known for engaging and informative presentations, and provides training in compiler development techniques. Many are surprised to discover that Walter is also the creator of the wargame Empire, which is still popular today over 40 years after its debut.

  • 10:00 Redub: Configuring, Building, and Iterating
    by Marcelo Mancini
    Audience: All
    Duration: 40 Minutes

    Dub is an amazing tool, but due to its features not being segregated enough, it can be difficult to contribute to the project and to identify bottlenecks. Redub is a tool focused mainly on building. It brings compatibility with dub, faster build times, and rewards good project structure.

    In this talk, I introduce the new tool and various aspects of its usage, including but not limiited to the motivation behind it, the base development plan, comparisons with dub and reggae, and more. My goal is to help D users discover new best practices that could benefit the entire D ecosystem, and to thing more about public and private dependencies.

    Marcelo Mancini is a game developer who works with web games. Web programming has always been all about compatibility, which motivated him to create Hipreme Engine, one of the biggest game engines made in D. He is also the developer of Redub, based on his experiences with Hipreme Engine, dub and other build tools outside of D. Redub was used to solve a problem with slow iteration inside Hipreme Engine.

  • 11:00 Software as Investment
    by Guillaume Piolat
    Audience: Advanced
    Duration: 40 Minutes

    We’ll devise together a tautologic, all-encompassing, theory of software that posits a composable economic value to every piece of software, however small.

    Through this lens, we’ll see in equations:

    * why core libraries tends to be so valuable
    * how we could define software debt and assets
    * what “ownership” means and for whom
    * if you should fix that bug or take that dependency

    This theory has no predictive power without a cost heuristic (else you would need to see the future), but the hope is that it’s useful nonetheless, or at least entertaining.

    Guillaume Piolat is an ex-C++ salaryman turned D software vendor. Struck by baldness at an early age, he created Auburn Sounds 10 years ago to enjoy the possibility of trickling down value directly from the user and get revenge from everyone that wronged him. Now established as one of the pitch-shifting world champions, he found out the hard way that few people enjoy talking about time-frequency.

  • 12:00 Lunch
  • 13:30 Avoid the Garbage Collector in 80 Lines
    by Dennis Korpel
    Audience: Intermediate
    Duration: 40 Minutes

    After an epiphany, I finally found it: the perfect memory allocator. Last year, I talked about stack memory and its limitations, but I've found a way around them. Now I have a scheme that combines the best parts of the Garbage Collector and manual memory management. It’s @safe, it’s @nogc, and it’s implemented in only 80 lines of code. The gist of it is that pointers to arenas are passed to return scope function parameters with default arguments. How it works exactly will be explained in the talk.

    Dennis Korpel is a recent CS graduate from Delft University of Technology. D became his language of choice after discovering it in 2018, and he is currently Pull Request manager for the D Language Foundation.

  • 14:30 std-compatible Task Parallelism on FreeRTOS
    by Tom Vander Aa
    Audience: Beginner/Intermediate
    Duration: 30 Minutes

    In this talk, we show the key role of the D programming language in the development of a task-based parallel programming framework for a novel compute-accelerator platform. The platform consists of a set of compute accelerators (like GPGPUs) and a management processor. The management processor’s role is to orchestrate the parallel execution of kernels on the accelerators. Using the D language for the code running on the management processor allowed us to write high-level, size-efficient code.

    The key features of D to achieve this are extensive use of templates, interoperability with the underlying FreeRTOS written in C, and BetterC. Since this is our first large project in D, we will also share some concrete highs and lows of using the language. Next to that, we discuss the generic user experience of D and lessons learned.

    This work has been carried out in the ExaScience Lab of the CSA division at imec. Special thanks to Robbert Gurdeep Singh, Geert Vanmeerbeeck, Wilfried Verachtert, and Roel Wuyts

    Tom Vander Aa is a researcher in the ExaScience Lab at imec. This lab uses novel high-performance computing architectures and programming models to generate breakthroughs in life sciences and biotechnology. The ExaScience lab has a profound interest in the interplay between the programming model, the programming language, the computer architecture and the user application, experimenting with languages like Go, LuaJit, Julia, Nim, and Lisp. This is the lab’s first big project using D. Tom himself obtained a PhD in 2005, in the domain of embedded computer architectures. After his PhD Tom spent most of his time writing compilers in C++ and optimizing applications code in C and C++. This is Tom’s first experience using D.

  • 15:30 Replacing DRuntime Hooks with Templates Across Three SAoCs
    by Teodor Dutu
    Audience: Advanced
    Duration: 45 Minutes

    In D, certain high-level constructs are replaced with calls to lower-level functions from DRuntime, called hooks, that provide the same functionality. This makes the compiler’s job easier by saving it from having to generate code for complex expressions itself. This process takes place in the compiler’s intermediate representation generator. This has the following disadvantages:

    1. The hook arguments are mostly void[] and require the TypeInfo hierarchy to extract type information at runtime. This is unnecessarily slow because all type information is available at compile-time.

    2. All hooks are linked into one large runtime library that all D programs link, regardless of which hooks they use. This makes DRuntime unnecessarily large for use cases where a subset of the hooks is used.

    This project eliminates these disadvantages by converting DRuntime hooks to templates and moving the lowering logic to the semantic phase. Thus, all new hooks are verified to respect the restrictions imposed by attributes, type information is leveraged at compile-time, and D executables will only contain code for the hooks they use. This brings performance benefits since runtime checks are moved to compile time.

    Teodor Dutu is a PhD student at the National University of Science and Technology POLITEHNICA Bucharest where he teaches computer architecture, compilers, and operating systems labs. His research is on compilers for advanced architectures, such as hardware accelerators. In addition, he is interested in compilers, programming language analysis, operating systems, security, and computer architecture, and he is passionate about open source. He is also a contributor to the D programming language and participated in three consecutive Symmetry Autumn of Code programs, winning the first two.

  • 16:30 The Future of Phobos: Version 3 and Beyond
    by Adam Wilson
    Audience: All
    Duration: 45 Minutes

    As time goes by, best practices evolve, needs change, and better ideas have appeared. What began as idle conversation in late 2023 has become a full-scale effort to forge the future of Phobos. Today, Phobos 3 has been under active development for 6 months and the ground-work for the future has been laid. But what does this mean for Phobos 2? What will be included in Phobos 3 and what will be cut? What comes after Phobos 3?

    In this talk we will discuss where Phobos 3 stands today, what work still remains to be completed, and finally where we want to take Phobos in the future. The goal of this talk is to provide a roadmap for all D engineers as they begin planning for the transition to Phobos 3.

    Adam is an independent contractor with over 22 years of software development experience specializing in libraries and tooling for high performance web services. Adam’s resume includes start-ups, consulting, and even a stint at Microsoft. He is currently using D to create tooling that supports the development and deployment of a SQL based web-service.

  • 18:00 End of Day One
  • Wednesday September 18th

  • 08:00 Breakfast Snacks
  • 08:55 Introduction
  • 09:00 Good Fun: Creating a Data-Oriented Parser/AST/Visitor Generator
    by Robert Schadek
    Audience: Advanced
    Duration: 40 Minutes

    When you think of parser/AST/visitor generators you normally think of classes, polymorphism, and pointers. This is, no doubt, the reasonable way to approach such a project. More fun can be had, though. Maybe we can even improve on things by not following the standard way, but having fun outside of the box.

    In this talk, we therefore explore what happens if we do the interesting/fun things instead of the reasonable, standard, boring things. These things include data-oriented design, array-based trees, bitmaps, and exploring hardware oddities.

    Robert Schadek received a doctorate degree in computer science from the University of Oldenburg. His dissertation was titled ‘Analysis and Development of Quorum Protocols for Real-World Network Topologies’and focused on quorum systems in combination with graphs. Since 2018, he has been happily using D in his day job working for Symmetry Investments.

  • 10:00 D and Buck2
    by Max Haughton
    Audience: All
    Duration: 40 Minutes

    Buck2 is a shiny new declarative build system from inside Facebook. I have been on an adventure making it speak D. As such, I will describe writing D rules in the ‘starlark’ build language that it uses, and then pontificate a bit on declarative build systems (at both micro and macro scales), toolchains, meta-build systems like reggae, and loop back around to dub.

    Max slings code for Symmetry Investments. Otherwise... all words, some action, no bona fides!

  • 11:00 We Need a New GC
    by Steven Schveighoffer and Amaury Séchet
    Audience: Advanced
    Duration: 40 Minutes

    In a world which can’t be stopped, we need a new hero. (Well, maybe we can stop it for a few microseconds...) In any case, the current garbage collector for D has been relatively stagnant in design since the development of DRuntime. We have had a few nice improvements, including fork-based, parallel scanning, and precise scanning. But we can do better. Our ideas on how to improve the performance of the GC get down to the lowest level of the hardware of modern systems, and try to squeeze every last bit of performance from the GC.

    This talk will delve into the details of why we need a new garbage collector, and how we can exploit modern memory and CPU architecture and use clever storage techniques to streamline GC allocations.

    Steve has been using D for 23 years professionally, and has written or helped write significant parts of DRuntime, including the array runtime, moduleinfo cycle detection, and AA static initialization. He has also written several prominent D libraries, including iopipe, and dcollections.

  • 12:00 Lunch
  • 13:30 The Search for Artificial Life in D
    by Murilo Miranda
    Audience: All
    Duration: 45 Minutes

    Have you ever tried to create life? Of course not! You’re not a god. But you could try to simulate life in a computer as many scientists have done. I’ve been doing that in D for months.

    I’ve ventured into the world of biology simulation, I’ve created a simulator where you can set up an environment in which you can watch organisms interact and evolve. This could be used for research, educational purposes, and fun. It was written purely in D. I’m striving to make it the best biology simulator in the world. Come watch my talk to learn more. I will talk about some evolutionary concepts such as RNA, DNA, natural selection, and biophysics, and I will be demonstrating the software as I explain in detail how it all works. Before the conference, feel free to watch this video that includes a demonstration.

    Murilo Miranda is a computer scientist from the University of Brasília (UnB). He works as a programmer, computer technician, and teacher of computer programming. He is also an indie game developer, overclocker, and casemodder in his free time. He maintains a blog about CS, and he recently started a Youtube channel (@256SecondsOfComputerScience).

  • 14:30 Exploring Declarative Programming Capabilities of D
    by Artha
    Audience: Intermediate
    Duration: 40 Minutes

    Fluid is a library for building general purpose graphical interfaces. To communicate the desired layout and style to the program, a common language has to be used. I will compare solutions used in different frameworks, explain D's advantages in declarative API design, and its significance for user interface programming.

    I am a hobbyist programmer with strong interest in user interface design, especially in regards to BBS, social media and multiplayer games. Since around 2015 I’ve been exploring various solutions, most importantly Android UI, web apps, and Godot Engine, in order to find the most suitable for my use cases. I started using D around 2021, which is when I initially created Fluid.

  • 15:30 The State of C++ Interoperability in D
    by Emmanuel Nyarko
    Audience: Intermediate
    Duration: 35 Minutes

    One of D’s goals in its interoperability with C++ is to be able to use some of the major C++ Standard Template Library from D. In this talk, I will reveal where we are in this process as a language. I will also cover real-life usage with their design philosophies, limitations, and the way forward in reaching seamless C++ integration.

    Emmanuel is a recent computer science bachelors graduate from the Kwame Nkrumah University of Science and Technology from Ghana. He started his experiential programming Journey contributing to D through the 2023 Symmmetry Autumn of Code where he worked on C++ STL interoperability. He has a keen interest in programming languages and operating systems development and is looking to contribute more to D and to other major systems in the world.

  • 16:30 Reworking the Range API for Phobos v3
    by Jonathan M. Davis
    Audience: Intermediate
    Duration: 40 Minutes

    A new version of D’s standard library, Phobos, is currently under development. We would like to fix some of the mistakes that have been made over the years which we haven’t been able to fix without breaking code, and we want to update Phobos according to the current best practices for D. Ranges are a big part of Phobos, and they are are being reworked as part of the update.

    Overall, ranges have worked very well for us since they were first introduced in Phobos v2. We would like that continue, but there are some issues with their current design which have come up over the years. We’re taking advantage of the opportunity Phobos gives us to implmeent otherwise breaking changes by improving upon the existing range design and fixing mistakes. This talk will go over the changes and why we’re making them.

    Jonathan M. Davis is the primary author of std.datetime and one of Phobos’s core contributors. He is a professional developer and has experience in a number of programming languages, including C++, Haskell, Java, and D. For better or worse, he’s well known in the D community for answering questions and being long-winded. He currently resides in Utah.

  • 18:00 End of Day Two
  • Thursday September 19th

  • 08:00 Breakfast Snacks
  • 08:55 Introduction
  • 09:00 Value Lifetimes and Move Semantics
    by Timon Gehr
    Audience: Intermediate/Advanced
    Duration: 40 Minutes

    In this talk, I will explore memory management in D, and how to reconcile manual memory management with garbage collection and type safety.

    Timon Gehr is an established researcher at ETH Zürich who has used D to implement a number of tools and programming languages for his research. He has opened almost 1% of all issues on the D issue tracker. He sometimes dabbles in DMD development and contributed the initial implementation of static foreach.

  • 10:00 Using Dustmite to Make Good Testcases
    by Mathis Beer
    Audience: Intermediate
    Duration: 30 Minutes

    D ships with dustmite, a tool that lets you take any D project with an issue and reduce it to a testcase. But using dustmite effectively requires some experience. Having filed many bugs with dustmite reductions, I will share reduction strategies and gotchas.

    At Funkwerk, our large and advanced codebase means we keep running into compiler and standard library issues. When something goes wrong, I use Dustmite to find a reduction.

  • 11:00 Integrating the New GC
    by Steven Schveighoffer and Amaury Séchet
    Audience: Advanced
    Duration: 40 Minutes

    Just when you thought we were done with GC talks, we have more for you!

    In this continued presentation about the new GC, we will talk about how we organize small allocations to reduce fragmentation, how we avoid lock contention when allocating, and how we optimize collections to take as little time away from your code as possible. We will also talk about integration with DRuntime and planned future improvements that can bring this new allocator further into the realm of modern GCs.

    D deserves to have a GC with few pauses and high multi-core performance. We hope to bring you that experience.

    Steve has been using D for 23 years professionally, and has written or helped write significant parts of DRuntime, including the array runtime, moduleinfo cycle detection, and AA static initialization. He has also written several prominent D libraries, including iopipe, and dcollections.

  • 12:00 Lunch
  • 13:30 Lightning Talks
    by Various
    Audience: All
    Duration: 45 Minutes

    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 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.

  • 14:30 The Case for Graphics Programming in D Part 2: Tech Demo
    by Mike Shah
    Audience: Intermediate
    Duration: 30 Minutes

    The D programming language and ecosystem provide many modern features which can help give developers a competitive advantage during the software development lifecycle. In this talk, I will discuss how D provides a competitive advantage for graphics application development (e.g., games, rendering), where any reduction in iteration time can improve outcomes. As an example, when creating an art style, having systems allowing rapid iteration can help improve visual fidelity, both in aesthetics and correctness of the application.

    Throughout the talk I will showcase visual examples, developed in a summer, that show off a graphics engine built completely in the D ecosystem. Topics will include: a hot reload system, a job system (using concurrency), and showcasing the architecture of a small graphics engine. This talk follows up a previous Dconf Online 2024 talk in which I make a case for using D for graphics programming—this time showing you the results (attendees need not have watched the previous talk).

    Mike discovered computer science at the age of 13 when googling “how do I make games”. Since that fateful Google search, Mike has worked as a freelance game developer, worked in industry for Intel, Sony PlayStation, Oblong, and a few other roles as a contracting 3D Senior Graphics Programmer. Mike also consults as a 3D Senior Graphics Engineer. In Michael’s spare time, he goes for long runs, plays video games while on his exercise bike, learns guitar, and considers himself an amateur pizza and wine maker. Mike YouTube channel covers various graphics and programming, including D!

  • 15:30 D-scanner: Migrating from libdparse to DMD-as-a-library
    by Vlăduț-Ștefan Riciu
    Audience: Beginner/Intermediate
    Duration: 30 Minutes

    D-Scanner is one of the most widely used static code analysis tools for D. It relies on libdparse, a third-party D parser implementation. As a consequence, every time the D frontend is modified, both libdparse and D-Scanner need to be updated. Given that D can be built as a compiler library, replacing libdparse with DMD-as-a-library will make it easier to tackle compiler updates.

    Over the past year, I have embarked on a transformative journey within D-Scanner, tasked with migrating from libdparse to DMD-as-a-library. In this talk, we will explore the migration process and address the challenges of keeping up with DMD-as-a-library, integrating with upstream, and maintaining trustworthy tests.

    My passion for programming started as a child, playing with Arduino. It continued by following an informatics high school and then a computer science university. Currently, I’m working as a Software Engineer at Adobe, and I’m finishing up my Bachelor’s Degree in computer science at University Politehnica of Bucharest. My main programming experience lies in the JVM world—Java and Kotlin. I’m interested in distributed systems, and recently I’ve been intrigued by the world of compilers and static code analysis.

  • 16:30 A Case Study of D’s Compiler Internals: When complexity impedes development
    by Razvan Nitu
    Audience: Intermediate
    Duration: 35 Minutes

    D has historically been open to the addition of new features. While some of have been net benefits to the language, others simply offer some sort of convenience while either increasing the codebase complexity or enabling patterns which are hard to maintain. This talk will present a series of such language features, exhibit the impact of their implmentations on the D codebase, and explore the alternative of removing them.

    Razvan Nitu has a PhD in computer science. He is also one of the Pull Request and Issue Managers for the D Language Foundation. His experience with D lies mostly in compiler development, but he occasionally contributes to DRuntime and Phobos. Razvan has been organizing D summer schools at his hometown university and mentoring students to work on D-related projects (such as integrating DMD-as-a-library in D-Scanner, pay-as-you-go DRuntime, D Google APIs, using D to write linux kernel drivers, etc.) for the past 6 years.

  • 18:00 End of Day Three


Every year, we offer a 15% Early-Bird discount for a limited window. This year, we were scheduled to open General registration at a rate of $450 starting from June 18th. But thanks to support from WEKA, we are able to keep the Early-Bird rate locked in. So the discounted rate of $382.50 is now the General rate for the remainder of the registration period. Thanks, WEKA!

GBP rates are based on the HMRC Exchange Rate for the current month. Note that this rate is static for the month and will most likely differ from the rate used by PayPal or your credit card company. You may find the USD PayPal link to result in a lower or higher charge on your GBP credit card than the GBP link.

A 20% VAT is added to the base registration rates.

General Registration Base Rate: $382.50 (£300.32)

At a base rate of $382.50, with 20% VAT, the total for General registration is $459 (£360.51). Register below!

Student Registration Base Rate: $100 (£78.54)

The student rate is a fixed $100 + 20% VAT, or $120 (£94.25), until General Registration closes. If you qualify, please contact for details on how to take advantage of this discounted rate.

Major Open Source Contributor Registration Base Rate: $250 (£196.36)

The rate for major open source contributors is a fixed $250 + 20% VAT, or $300 (£235.63), until General Registration closes. Eligibility for this discount is determined on a case-by-case basis. If you think you qualify, please contact for more information.

Hardship Rate

If you would like to attend DConf but cannot afford any of the above rates, we are willing to offer you a special hardship rate. This is only a discount on registration. We cannot assist you with transportation or lodging. Please contact to explain your situation, and we’ll provide you with more details.

Register General USD: $382.50 + 20% VAT ($459)

Register General GBP: £300.32 + 20% VAT (£360.51)

Please be aware that by attending the conference, you acknowledge that you are responsible for any property that you bring to the venue and that neither the D Language Foundation nor its sponsors can assume any responsibility for damaged, stolen or lost property belonging to the attendees.


Our DConf ’24 venue is CodeNode, a space in Central London specifically designed for tech conferences. It’s conveniently located close between Moorgate and Liverpool Street stations and is a 10–15 minute walk from Old Street Station to the north.

Our presentations will happen on the ground floor in the CTRL room, and we’ll have the entirety of the ESC area downstairs to ourselves, where attendees can relax, chat, or play table tennis or foosball between talks.


There are several budget hotels in easy walking distance. The following are some options that, according to Google Maps, are less than a 20-minute walk from the venue. Some of them are near an underground station that is one stop away from Moorgate or Liverpool Street stations. Click a link to see the walking route(s) between a hotel and the venue. On the map, you’ll find links to reserve a room. Note that most attendees generally stay at the Travelodge London Central City Road.


Every evening during the first three nights of DConf means only one thing: BeerConf! Ethan Watson coined the term in 2016 as a name for what happens at the designated evening gathering spot at every DConf. In 2019 and 2022, we were able to hire space at pubs for BeerConf. Unfortunately, last year and again this year, pub hire rates have been well beyond our budget.

Even so, we’re fortunate this year in that an anonymous donor has sponsored one night of BeerConf at a pub! We’ll be at The Trinity Bell on Mitre Street, roughly 15 minutes southeast of the venue on foot. On the first night of the conference, September 17, drinks are on the house for all conference attendees from 18:00 until the tab runs out. When you get there, be sure to raise a glass in honor of our anonymous benefactor.

We’re hoping to find more sponsors for the other two nights. In the event we’re unable to, we’ll designate a meetup spot. Unless and until we update this space with that information, the default location is the lobby bar of the Travelodge Central City Road.


Symmetry Investments

DConf ’24 is sponsored by our friends at Symmetry Investments. With offices in Hong Kong, Singapore, London, Jersey, and the Cayman Islands, Symmetry employs D in their investment management mission. This is the fourth time they’ve sponsored DConf, and we are thankful for their continued support. They are also the sponsors of the Symmetry Autumn of Code, an annual event that, since 2018, has provided experience to emerging programmers while enhancing the D ecosystem. We couldn’t be more excited to bring DConf to London once again with Symmetry’s support.


DConf ’24 is supported by our friends at WEKA. WEKA is a fast-growing company that is building a cloud and AI-native data platform that helps to solve complex data challenges for the world’s leading enterprises and preeminent research organizations. WEKA is a great place to work for developers looking to sharpen their D coding skills and work on really interesting use cases.


Additional funding for DConf ’24 has been provided by our friends at Decard. Decard harnesses the power of decentralization, security, and scalability to build robust, asset agnostic financial products and services. Co-founder and CEO Theis Simonsen says, “D is not just a programming language; it is a development shift towards efficiency, safety, and expressiveness without forcing specific programming paradigms.”