D Language Foundation

Mentors: Student: Quang Ha

My project wants to build a Vulkan compute system for DCompute. At the moment, DCompute does not have a Vulkan backend. This makes it hard to use the language on different platforms. I will fix this by changing the LDC compiler to make SPIR-V code. I will use a "Wrapper Kernel" method to manage memory. I will also build a runtime to manage memory and run shaders using the Vulkan API. My final work will include LDC updates, a new runtime, tests, and documents.

Mentors: Student: Abul Hossain Khan

This project aims to build an automated performance regression detection system for the D compiler (DMD). It introduces a PR-based benchmarking bot that compares changes against the master branch and reports meaningful differences in compile time, memory usage, and binary size. Alongside this, a modular benchmark suite will simulate real-world and synthetic workloads to ensure accurate measurements. A lightweight dashboard will track performance trends over time, helping identify regressions and evaluate optimizations. The system is designed to be practical, maintainable, and tightly integrated with the existing D ecosystem.

Mentors: Student: Hariprakash V

This project adds a Ninja build backend to DUB, the D package manager and build tool used by the D ecosystem. Currently, DUB primarily drives builds via direct compiler invocations. This limits incremental build performance, parallelism, and integration with modern build tooling. The proposal introduces a backend that allows DUB to generate Ninja build files and delegate compilation to Ninja. This enables faster incremental builds, better dependency tracking, improved parallel execution, and easier IDE/toolchain integration.

Mentors: Student: Albert Guiman

This project proposes to modernize DRuntime by converting legacy runtime hooks (functions that implement high-level language constructs like array operations and associative arrays) into compile-time templates. These hooks currently rely on dynamic type resolution via TypeInfo, introducing overhead that limits optimization opportunities. By leveraging D’s template metaprogramming, this work will enable compile-time specialization of these operations, improving runtime performance, potentially reducing binary sizes, and simplifying DRuntime maintenance. To achieve all this, my proposed solution comprises of three systematic steps for each hook: 1. Template implementation: Rewriting the hook as a template function in DRuntime, replacing the runtime TypeInfo queries with compile-time type parameters. 2. Compiler Integration: Modifying the DMD frontend to generate calls to the new templated hooks during the lowering phase. 3. Validation and Benchmarking: Verifying correctness through unit tests and quantifying performance improvements using benchmarks.

Mentors: Student: Fei

D’s current JSON libraries (e.g., Phobos’s std.json) rely heavily on dynamic typing, which sacrifices type safety and performance—critical drawbacks for systems programming. For example, parsing JSON data into a generic JSONValue container forces developers to manually validate field types and existence at runtime, introducing overhead and error-prone code. This project addresses these limitations and enables type-safe JSON processing with constant memory by building higher-level functionalities on top of jsoniopipe, which exemplifies the language’s strengths in compile-time function evaluation(CTFE) and introspection.