Change Log: 2.113.0

The compiler now lowers associative array operations to templates defined in core.internal.newaa instead of relying on a precompiled implementation based on TypeInfo.

In addition to better performance by not having to go through TypeInfo and allowing inlining of simple operations, this paves the way for proper inference of function attributes inherited from key and value constructors, toHash() on the key and comparison of key values. This inference is currently mostly avoided to keep backward compatibility with the runtime implementation that doesn't check function attributes.

Some changes that are the result of the refactoring:

• AA support no longer available at CTFE without object.d/newaa.d. Some operations used to work, but now need the lowerings before these can be intercepted by the interpreter.

• creating an AA literal at runtime passes keys and values as arguments normally, not with special move/blit operations, so more postblit/destructor operations can happen

• _d_assocarrayliteralTXTrace removed. Apart from the creation of associative array literals no other AA operation is hooked for -profile-gc. You will now see the allocations as done by the AA implementation.

• aa[key] = S() with S.__ctor and S.opAssign is no longer a double lookup

• aa.remove(key) now works with alias this

Similar to auto ref parameters in 2.111, it's now deprecated to declare an auto ref return type without putting those two keywords next to each other as well.

ref auto int f() => 3;
auto { ref int g() => 3; }

// Correction:
auto ref f() => 3;
auto ref g() => 3;

There is no longer a requirement to throw the switch -preview=bitfields.

This used to give a warning when compiled with -w and now gives an error:

int i, j;
if (i)
    if (j)
        return 1;
    else    // Error: else is dangling, add { } after condition `if (i)`
        return 2;

The compiler now accepts c++23 as a supported standard for -extern-std=. Currently this only changes the value of __traits(getTargetInfo, "cppStd").

A new switch is added, the external import path (-extI). It is similar to the import path switch (-I) except it indicates that a module found from it is external to the currently compiling binary.

It is used on Windows when the dllimport override switch is set to anything other than none to force an external module's symbols as DllImport.

If a build system supports the external import path switch, it is recommend to not use the all option for the dllimport override switch which applies to symbols that should not be getting DllImport'd.

Similar to the __import extension, the __module keyword brings D's module declaration to C.

It's particularly useful when you want to import multiple C files with the same name (e.g. hello/utils.c and world/utils.c), since both have to be imported with import utils when they are listed on the command line, resulting in conflicts.

Now you can do:

hello/utils.c:

#if __IMPORTC__
__module hello.utils;
#endif

int sqr(int x) { return x * x; }

world/utils.c:

#if __IMPORTC__
__module world.utils;
#endif

int max(int a, int b) { return a > b ? a : b; }

app.d:

import hello.utils;
import world.utils;

static assert(sqr(3) == 9);
static assert(max(3, 5) == 5);

A __module declaration can appear anywhere in the top level scope. When there are multiple, the first one will be used. Therefore, every #include containing a __module declaration should come after the file's own module declaration, or it will be overwritten. When you always put the __module declaration at the very top like in D, there won't be such problems.

This is to prevent potential mistakes when op= assignment would implicitly truncate the right hand side expression from a non-zero value to zero.

uint a;
float b = 0.1;
a += b; // Deprecation: `uint += float` is performing truncating conversion

The corrective action if truncating was intentional is to explicitly cast the floating point expression to integer.

a += cast(uint) b;

The internal runtime function _d_arraysetlengthT was templatized to operate directly on the type T, removing its dependency on TypeInfo. This improves type safety, reduces runtime reflection, and allows the compiler to generate specialized code paths for different array element types.

This change preserves the semantics of .length assignment on dynamic arrays, ensuring memory allocation, element initialization, and postblit handling continue to work as expected.

/**
Resize a dynamic array by setting its `.length` property.

New elements are initialized according to their type:
- Zero-initialized if applicable
- Default-initialized via `emplace`
- Or `memcpy` if trivially copyable
*/
size_t _d_arraysetlengthT(Tarr : T[], T)(return ref scope Tarr arr, size_t newlength);

int[] a = [1, 2];
a.length = 3; // becomes _d_arraysetlengthT!(int)(a, 3)

This reduces runtime dependency on TypeInfo, making the function more predictable and performant.

See also: PR #21151

This refactorization discards the TypeInfo parameter, replacing it with a template type parameter.

This refactorization discards the TypeInfo parameter, replacing it with a template type parameter.

These map to a single x86_64 instruction and have accordingly been optimized via inline assembly.

import core.int128;

ulong a, b;
Cent product128 = mul(a, b);

ulong divisor64 = …;
ulong modulus64;
ulong quotient64 = udivmod(product128, divisor64, modulus64);

macOS 15.4 has introduced an undocumented ABI change to the format of thread local variable section, which causes almost all executable built with previous D compiler versions to crash during initialization, if they use DRuntime. This release introduces a mitigation for this issue that is backwards compatible with previous versions of macOS.

This prevents linking errors when using -betterC. For example:

import core.sys.posix.stdlib;
import core.sys.posix.unistd;

extern(C) int main()
{
    int status, pid = vfork();
    if (pid == 0)
    {
        // ...
        return 0;
    }

    waitpid(pid, &status, 0);
    if (WIFEXITED(status))
    {
        // ...
    }
    return 0;
}

This would fail to compile with the -betterC flag:

Error: undefined reference to `core.sys.posix.sys.wait.WIFEXITED(int)`
       referenced from `main`

The reason is that WIFEXITED is a C macro that was translated to a D function in druntime, which requires linking with druntime to use. Now that it's a template, it will be lazily instantiated and the program compiles.

The new lazyCache function provides a lazily evaluated range caching mechanism. Unlike cache, which eagerly evaluates range elements during construction, lazyCache defers evaluation until elements are explicitly requested.

auto result = iota(-4, 5).map!(a => tuple(a, expensiveComputation(a)))().lazyCache();
// No computations performed at this point

auto firstElement = result.front;
// First element is now evaluated

See the std.algorithm.iteration.lazyCache documentation for more details.

To restore compatibility with older Linux platforms where getrandom() is unavailable either due to an outdated kernel or a legacy C library, Phobos now ships with a shim that emulates a limited subset of getrandom()’s behavior by reading random bytes from /dev/urandom.

To enable the shim, build DMD and Phobos with the environment variable LINUX_LEGACY_EMULATE_GETRANDOM set to 1.

cd phobos
LINUX_LEGACY_EMULATE_GETRANDOM=1 make

This functionality is a temporary fix and expected to be removed again soon by an upcoming release (approx. v2.112.0 or v2.113.0). The expected change is to replace the current “binding or shim” solution with a syscall wrapper and automatic /dev/urandom fallback.

This Phobos release introduces an internal multi-backend system for the retrieval of entropy (as in cryptographically-secure random numbers obtained from a suitable random number generator provided by the operating system).

The current implementation supports the getrandom syscall on Linux.

On BSD systems arc4random_buf or getentropy are used — depending on which is implemented by the OS and powered by a secure (non-RC4) algorithm.

Additionally, reading entropy from the character devices /dev/urandom and /dev/random is available on all POSIX targets.

On Windows BCryptGenRandom (from the Cryptography API: Next Generation (“BCrypt”)) is provided as a backend. CryptGenRandom from the legacy CryptoAPI is not supported for the time being.

Furthermore, this replaces the getrandom backwards compatibility shim that had been added by v2.111.1 for Linux targets. Instead backwards compatibility is now provided by a hunt strategy algorithm that tries potentially available entropy sources one by one to find one that is available on the running system. Given that the character devices serve as a fallback option here, urandom is favored over random. That is because modern kernel versions — where random would exhibit the usually more preferable behavior of blocking only until the entropy pool has been initialized — will also provide the getrandom syscall in the first place. Performing the syscall, in turn, is even better as it does not depend on the runtime environment exposing the special devices in predefined locations, thus working also within chroot environments.

This Unicode update was released September 9, 2025, and adds new blocks with characters. See: https://www.unicode.org/versions/Unicode17.0.0/

import std;

void main()
{
    const alphaCount = iota(0, dchar.max).filter!(std.uni.isAlpha).walkLength;
    writeln(alphaCount);
    // formerly: 142759
    // now:      147421
}

Add uuid v7 support to the UUID type located in std.uuid. The first 48 bits of v7 stores the milliseconds since the unix epoch (1970-01-01), additionally 74 bit are used to store random data.

Example:

SysTime st = DateTime(2025, 8, 19, 10, 38, 45);
UUID u = UUID(st);
SysTime o = u.v7Timestamp();
assert(o == st);

string s = u.toString();
UUID u2 = UUID(s);
SysTime o2 = u2.v7Timestamp();
assert(o2 == st);

These functions are variants of the existing text, wtext, and dtext functions. Instead of returning a string, they write their output to an output range.

Like text, writeText can accept an interpolated expression sequence as an argument.

Example:

import std.conv : writeText;
import std.array : appender;

auto output = appender!string();
output.writeText(i"2 + 2 == $(2 + 2)");
assert(output.data == "2 + 2 == 4");