If you spot a problem with this page, click here to create a Bugzilla issue.

API documentation

Module Description

std.algorithm.comparison This is a submodule of std.algorithm. It contains generic comparison algorithms.

std.algorithm.iteration This is a submodule of std.algorithm. It contains generic iteration algorithms.

std.algorithm.mutation This is a submodule of std.algorithm. It contains generic mutation algorithms.

std.algorithm.searching This is a submodule of std.algorithm. It contains generic searching algorithms.

std.algorithm.setops This is a submodule of std.algorithm. It contains generic algorithms that implement set operations.

std.algorithm.sorting This is a submodule of std.algorithm. It contains generic sorting algorithms.

std.container.array This module provides an Array type with deterministic memory usage not reliant on the GC, as an alternative to the built-in arrays.

std.container.binaryheap This module provides a BinaryHeap (aka priority queue) adaptor that makes a binary heap out of any user-provided random-access range.

std.container.dlist This module implements a generic doubly-linked list container. It can be used as a queue, dequeue or stack.

std.container.rbtree This module implements a red-black tree container.

std.container.slist This module implements a singly-linked list container. It can be used as a stack.

std.container.util This module contains some common utilities used by containers.

std.datetime.date


Category	Functions
Main date types	`Date` `DateTime`
Other date types	`Month` `DayOfWeek` `TimeOfDay`
Date checking	`valid` `validTimeUnits` `yearIsLeapYear` `isTimePoint` `enforceValid`
Date conversion	`daysToDayOfWeek` `monthsToMonth`
Time units	`cmpTimeUnits` `timeStrings`
Other	`AllowDayOverflow` `DateTimeException`

std.datetime.interval


Category	Functions
Main types	`Interval` `Direction`
Special intervals	`everyDayOfWeek` `everyMonth` `everyDuration`
Special intervals	`NegInfInterval` `PosInfInterval`
Underlying ranges	`IntervalRange` `NegInfIntervalRange` `PosInfIntervalRange`
Flags	`PopFirst`

std.datetime.stopwatch Module containing some basic benchmarking and timing functionality.

std.datetime.systime


Category	Functions
Types	`Clock` `SysTime` `DosFileTime`
Conversion	`parseRFC822DateTime` `DosFileTimeToSysTime` `FILETIMEToStdTime` `FILETIMEToSysTime` `stdTimeToFILETIME` `stdTimeToUnixTime` `SYSTEMTIMEToSysTime` `SysTimeToDosFileTime` `SysTimeToFILETIME` `SysTimeToSYSTEMTIME` `unixTimeToStdTime`

std.datetime.timezone


Category	Functions
Time zones	`TimeZone` `UTC` `LocalTime` `PosixTimeZone` `WindowsTimeZone` `SimpleTimeZone`
Utilities	`clearTZEnvVar` `parseTZConversions` `setTZEnvVar` `TZConversions`

std.digest.crc Cyclic Redundancy Check (32-bit) implementation.

std.digest.hmac This package implements the hash-based message authentication code (HMAC) algorithm as defined in RFC2104. See also the corresponding Wikipedia article.

std.digest.md Computes MD5 hashes of arbitrary data. MD5 hashes are 16 byte quantities that are like a checksum or CRC, but are more robust.

std.digest.murmurhash Computes MurmurHash hashes of arbitrary data. MurmurHash is a non-cryptographic hash function suitable for general hash-based lookup. It is optimized for x86 but can be used on all architectures.

std.digest.ripemd Computes RIPEMD-160 hashes of arbitrary data. RIPEMD-160 hashes are 20 byte quantities that are like a checksum or CRC, but are more robust.

std.digest.sha Computes SHA1 and SHA2 hashes of arbitrary data. SHA hashes are 20 to 64 byte quantities (depending on the SHA algorithm) that are like a checksum or CRC, but are more robust.

std.experimental.allocator.building_blocks.affix_allocator

std.experimental.allocator.building_blocks.aligned_block_list AlignedBlockList represents a wrapper around a chain of allocators, allowing for fast deallocations and preserving a low degree of fragmentation by means of aligned allocations.

std.experimental.allocator.building_blocks.allocator_list

std.experimental.allocator.building_blocks.ascending_page_allocator

std.experimental.allocator.building_blocks.bitmapped_block

std.experimental.allocator.building_blocks.bucketizer

std.experimental.allocator.building_blocks.fallback_allocator

std.experimental.allocator.building_blocks.free_list

std.experimental.allocator.building_blocks.free_tree

std.experimental.allocator.building_blocks.kernighan_ritchie

std.experimental.allocator.building_blocks.null_allocator

std.experimental.allocator.building_blocks.quantizer

std.experimental.allocator.building_blocks.region

std.experimental.allocator.building_blocks.scoped_allocator

std.experimental.allocator.building_blocks.segregator

std.experimental.allocator.building_blocks.stats_collector Allocator that collects useful statistics about allocations, both global and per calling point. The statistics collected can be configured statically by choosing combinations of Options appropriately.

std.experimental.allocator.building_blocks

Assembling Your Own Allocator

std.experimental.allocator.common Utility and ancillary artifacts of std.experimental.allocator. This module shouldn't be used directly; its functionality will be migrated into more appropriate parts of std.

std.experimental.allocator.gc_allocator D's built-in garbage-collected allocator.

std.experimental.allocator.mallocator The C heap allocator.

std.experimental.allocator.mmap_allocator

std.experimental.allocator.showcase Collection of typical and useful prebuilt allocators using the given components. User code would typically import this module and use its facilities, or import individual heap building blocks and assemble them.

std.experimental.allocator.typed This module defines TypedAllocator, a statically-typed allocator that aggregates multiple untyped allocators and uses them depending on the static properties of the types allocated. For example, distinct allocators may be used for thread-local vs. thread-shared data, or for fixed-size data (struct, class objects) vs. resizable data (arrays).

std.experimental.logger.core

std.experimental.logger.filelogger

std.experimental.logger.multilogger

std.experimental.logger.nulllogger

std.experimental.allocator High-level interface for allocators. Implements bundled allocation/creation and destruction/deallocation of data including structs and classes, and also array primitives related to allocation. This module is the entry point for both making use of allocators and for their documentation.

std.experimental.checkedint

std.experimental.logger Implements logging facilities.

std.experimental.typecons This module implements experimental additions/modifications to std.typecons.

std.net.curl Networking client functionality as provided by libcurl. The libcurl library must be installed on the system in order to use this module.

std.net.isemail Validates an email address according to RFCs 5321, 5322 and others.

std.range.interfaces This module is a submodule of std.range.

std.range.primitives This module is a submodule of std.range.

std.windows.charset Support UTF-8 on Windows 95, 98 and ME systems.

std.windows.syserror Convert Win32 error code to string.

std.algorithm This package implements generic algorithms oriented towards the processing of sequences. Sequences processed by these functions define range-based interfaces. See also Reference on ranges and tutorial on ranges.

std.array Functions and types that manipulate built-in arrays and associative arrays.

std.ascii Functions which operate on ASCII characters.

std.base64 Support for Base64 encoding and decoding.

std.bigint Arbitrary-precision ('bignum') arithmetic.

std.bitmanip Bit-level manipulation facilities.

std.compiler Identify the compiler used and its various features.

std.complex This module contains the Complex type, which is used to represent complex numbers, along with related mathematical operations and functions.

std.concurrency This is a low-level messaging API upon which more structured or restrictive APIs may be built. The general idea is that every messageable entity is represented by a common handle type called a Tid, which allows messages to be sent to logical threads that are executing in both the current process and in external processes using the same interface. This is an important aspect of scalability because it allows the components of a program to be spread across available resources with few to no changes to the actual implementation.

std.container This module defines generic containers.

std.conv A one-stop shop for converting values from one type to another.

std.csv Implements functionality to read Comma Separated Values and its variants from an input range of dchar.

std.datetime

std.demangle Demangle D mangled names.

std.digest This module describes the digest APIs used in Phobos. All digests follow these APIs. Additionally, this module contains useful helper methods which can be used with every digest type.

std.encoding Classes and functions for handling and transcoding between various encodings.

std.exception This module defines functions related to exceptions and general error handling. It also defines functions intended to aid in unit testing.

std.file Utilities for manipulating files and scanning directories. Functions in this module handle files as a unit, e.g., read or write one file at a time. For opening files and manipulating them via handles refer to module std.stdio.

std.format This module implements the formatting functionality for strings and I/O. It's comparable to C99's vsprintf() and uses a similar format encoding scheme.

std.functional Functions that manipulate other functions.

std.getopt Processing of command line options.

std.json JavaScript Object Notation

std.math Contains the elementary mathematical functions (powers, roots, and trigonometric functions), and low-level floating-point operations. Mathematical special functions are available in std.mathspecial.

std.mathspecial Mathematical Special Functions

std.meta Templates to manipulate template parameter sequences (also known as alias sequences).

std.mmfile Read and write memory mapped files.

std.numeric This module is a port of a growing fragment of the numeric header in Alexander Stepanov's Standard Template Library, with a few additions.

std.outbuffer Serialize data to ubyte arrays.

std.parallelism std.parallelism implements high-level primitives for SMP parallelism. These include parallel foreach, parallel reduce, parallel eager map, pipelining and future/promise parallelism. std.parallelism is recommended when the same operation is to be executed in parallel on different data, or when a function is to be executed in a background thread and its result returned to a well-defined main thread. For communication between arbitrary threads, see std.concurrency.

std.path This module is used to manipulate path strings.

std.process Functions for starting and interacting with other processes, and for working with the current process' execution environment.

std.random Facilities for random number generation.

std.range This module defines the notion of a range. Ranges generalize the concept of arrays, lists, or anything that involves sequential access. This abstraction enables the same set of algorithms (see std.algorithm) to be used with a vast variety of different concrete types. For example, a linear search algorithm such as find works not just for arrays, but for linked-lists, input files, incoming network data, etc.

std.regex Regular expressions are a commonly used method of pattern matching on strings, with regex being a catchy word for a pattern in this domain specific language. Typical problems usually solved by regular expressions include validation of user input and the ubiquitous find & replace in text processing utilities.

std.signals Signals and Slots are an implementation of the Observer Pattern. Essentially, when a Signal is emitted, a list of connected Observers (called slots) are called.

std.socket Socket primitives.

std.stdint D constrains integral types to specific sizes. But efficiency of different sizes varies from machine to machine, pointer sizes vary, and the maximum integer size varies. stdint offers a portable way of trading off size vs efficiency, in a manner compatible with the stdint.h definitions in C.

std.stdio Standard I/O functions that extend core.stdc.stdio. core.stdc.stdio is publically imported when importing std.stdio.

std.string String handling functions.

std.system Information about the target operating system, environment, and CPU.

std.traits Templates which extract information about types and symbols at compile time.

std.typecons This module implements a variety of type constructors, i.e., templates that allow construction of new, useful general-purpose types.

std.uni

The std.uni module provides an implementation of fundamental Unicode algorithms and data structures. This doesn't include UTF encoding and decoding primitives, see decode and encode in std.utf for this functionality.

std.uri Encode and decode Uniform Resource Identifiers (URIs). URIs are used in internet transfer protocols. Valid URI characters consist of letters, digits, and the characters ;/?:@&=+$,-_.!~*'() Reserved URI characters are ;/?:@&=+$ Escape sequences consist of % followed by two hex digits.

std.utf Encode and decode UTF-8, UTF-16 and UTF-32 strings.

std.uuid A UUID, or Universally unique identifier, is intended to uniquely identify information in a distributed environment without significant central coordination. It can be used to tag objects with very short lifetimes, or to reliably identify very persistent objects across a network.

std.variant This module implements a discriminated union type (a.k.a. tagged union, algebraic type). Such types are useful for type-uniform binary interfaces, interfacing with scripting languages, and comfortable exploratory programming.

std.xml Warning: This module is considered out-dated and not up to Phobos' current standards. It will be removed from Phobos in 2.101.0. If you still need it, go to https://github.com/DigitalMars/undeaD

std.zip Read and write data in the zip archive format.

std.zlib Compress/decompress data using the zlib library.

core.gc.config Contains the garbage collector configuration.

core.gc.gcinterface Contains the internal GC interface.

core.gc.registry Contains a registry for GC factories.

core.stdcpp.allocator D binding to C++ std::allocator.

core.stdcpp.array D header file for interaction with C++ std::array.

core.stdcpp.exception Interface to C++

core.stdcpp.memory D binding to C++ .

core.stdcpp.new_ D binding to C++

core.stdcpp.string D header file for interaction with C++ std::string.

core.stdcpp.string_view D header file for interaction with C++ std::string_view.

core.stdcpp.type_traits D header file for interaction with C++ std::type_traits.

core.stdcpp.typeinfo Interface to C++

core.stdcpp.utility D header file for interaction with Microsoft C++

core.stdcpp.vector D header file for interaction with C++ std::vector.

core.stdcpp.xutility D header file for interaction with Microsoft C++

core.sync.barrier The barrier module provides a primitive for synchronizing the progress of a group of threads.

core.sync.condition The condition module provides a primitive for synchronized condition checking.

core.sync.config The config module contains utility routines and configuration information specific to this package.

core.sync.event The event module provides a primitive for lightweight signaling of other threads (emulating Windows events on Posix)

core.sync.exception Define base class for synchronization exceptions.

core.sync.mutex The mutex module provides a primitive for maintaining mutually exclusive access.

core.sync.rwmutex The read/write mutex module provides a primitive for maintaining shared read access and mutually exclusive write access.

core.sync.semaphore The semaphore module provides a general use semaphore for synchronization.

core.thread.context The thread module provides support for thread creation and management.

core.thread.fiber The fiber module provides OS-indepedent lightweight threads aka fibers.

core.thread.osthread The osthread module provides low-level, OS-dependent code for thread creation and management.

core.thread.threadbase The threadbase module provides OS-independent code for thread storage and management.

core.thread.threadgroup The osthread module provides types used in threads modules.

core.thread.types This module provides types and constants used in thread package.

core.atomic The atomic module provides basic support for lock-free concurrent programming.

core.attribute This module contains UDA's (User Defined Attributes) either used in the runtime or special UDA's recognized by compiler.

core.bitop This module contains a collection of bit-level operations.

core.checkedint This module implements integral arithmetic primitives that check for out-of-range results.

core.cpuid Identify the characteristics of the host CPU, providing information about cache sizes and assembly optimisation hints. This module is provided primarily for assembly language programmers.

core.demangle The demangle module converts mangled D symbols to a representation similar to what would have existed in code.

core.exception The exception module defines all system-level exceptions and provides a mechanism to alter system-level error handling.

core.math Builtin mathematical intrinsics

core.memory This module provides an interface to the garbage collector used by applications written in the D programming language. It allows the garbage collector in the runtime to be swapped without affecting binary compatibility of applications.

core.runtime The runtime module exposes information specific to the D runtime code.

core.simd Builtin SIMD intrinsics

core.thread The thread module provides support for thread creation and management.

core.time Module containing core time functionality, such as Duration (which represents a duration of time) or MonoTime (which represents a timestamp of the system's monotonic clock).

core.vararg The vararg module is intended to facilitate vararg manipulation in D. It should be interface compatible with the C module "stdarg," and the two modules may share a common implementation if possible (as is done here).

core.volatile This module declares intrinsics for volatile operations.

dmd.backend.aarray Compiler implementation of the D programming language.

dmd.backend.backconfig Compiler implementation of the D programming language.

dmd.backend.backend Compiler implementation of the D programming language.

dmd.backend.barray Compiler implementation of the D programming language.

dmd.backend.bcomplex Compiler implementation of the D programming language.

dmd.backend.blockopt Compiler implementation of the D programming language.

dmd.backend.cc Compiler implementation of the D programming language.

dmd.backend.cdef Compiler implementation of the D programming language.

dmd.backend.cg Various global symbols.

dmd.backend.cg87 Compiler implementation of the D programming language.

dmd.backend.cgcod Top level code for the code generator.

dmd.backend.cgcs Compiler implementation of the D programming language.

dmd.backend.cgcse Compiler implementation of the D programming language.

dmd.backend.cgcv Compiler implementation of the D programming language.

dmd.backend.cgelem Compiler implementation of the D programming language.

dmd.backend.cgen Generate code instructions

dmd.backend.cgobj Compiler implementation of the D programming language.

dmd.backend.cgreg Compiler implementation of the D programming language.

dmd.backend.cgsched Compiler implementation of the D programming language.

dmd.backend.cgxmm Compiler implementation of the D programming language.

dmd.backend.cod1 Compiler implementation of the D programming language.

dmd.backend.cod2 Compiler implementation of the D programming language.

dmd.backend.cod3 Compiler implementation of the D programming language.

dmd.backend.cod4 Compiler implementation of the D programming language.

dmd.backend.cod5 Compiler implementation of the D programming language.

dmd.backend.code Compiler implementation of the D programming language.

dmd.backend.code_x86 Constants and data structures specific to the x86 platform.

dmd.backend.codebuilder Compiler implementation of the D programming language.

dmd.backend.cv4 Codeview 4 stuff See "Microsoft Symbol and Type OMF" document

dmd.backend.cv8 Compiler implementation of the D programming language.

dmd.backend.dcgcv Compiler implementation of the D programming language.

dmd.backend.dcode Compiler implementation of the D programming language.

dmd.backend.debugprint Compiler implementation of the D programming language.

dmd.backend.dlist Interface to the C linked list type.

dmd.backend.dout Compiler implementation of the D programming language.

dmd.backend.drtlsym Compiler implementation of the D programming language.

dmd.backend.dt Compiler implementation of the D programming language.

dmd.backend.dtype Compiler implementation of the D programming language.

dmd.backend.dvarstats Compiler implementation of the D programming language.

dmd.backend.dvec Compiler implementation of the D programming language.

dmd.backend.dwarf Definitions for DWARF debug infos (v3)

dmd.backend.dwarfdbginf Compiler implementation of the D programming language.

dmd.backend.dwarfeh Compiler implementation of the D programming language. Implements LSDA (Language Specific Data Area) table generation for Dwarf Exception Handling.

dmd.backend.ee Compiler implementation of the D programming language.

dmd.backend.el Compiler implementation of the D programming language.

dmd.backend.elem Compiler implementation of the D programming language.

dmd.backend.elfobj Compiler implementation of the D programming language.

dmd.backend.elpicpie Generate elems for fixed, PIC, and PIE code generation.

dmd.backend.errors Compiler implementation of the D programming language.

dmd.backend.evalu8 Compiler implementation of the D programming language.

dmd.backend.exh Compiler implementation of the D programming language.

dmd.backend.fp Compiler implementation of the D programming language.

dmd.backend.gdag Compiler implementation of the D programming language.

dmd.backend.gflow Code to do the Data Flow Analysis (doesn't act on the data).

dmd.backend.global Compiler implementation of the D programming language.

dmd.backend.glocal Compiler implementation of the D programming language.

dmd.backend.gloop Compiler implementation of the D programming language.

dmd.backend.go Compiler implementation of the D programming language.

dmd.backend.goh Compiler implementation of the D programming language.

dmd.backend.gother Other data flow analysis based optimizations.

dmd.backend.gsroa Compiler implementation of the D programming language.

dmd.backend.iasm Declarations for ptrntab.d, the instruction tables for the inline assembler.

dmd.backend.machobj Compiler implementation of the D programming language.

dmd.backend.md5

dmd.backend.melf Compiler implementation of the D programming language.

dmd.backend.mem Compiler implementation of the D programming language.

dmd.backend.mscoff Microsoft COFF object file format

dmd.backend.mscoffobj Compiler implementation of the D programming language.

dmd.backend.newman Compiler implementation of the D programming language.

dmd.backend.nteh Compiler implementation of the D programming language.

dmd.backend.obj Compiler implementation of the D programming language.

dmd.backend.oper Compiler implementation of the D programming language.

dmd.backend.outbuf Compiler implementation of the D programming language.

dmd.backend.pdata Compiler implementation of the D programming language.

dmd.backend.ph2 Compiler implementation of the D programming language.

dmd.backend.ptrntab Instruction tables for inline assembler.

dmd.backend.rtlsym Compiler implementation of the D programming language.

dmd.backend.symbol Compiler implementation of the D programming language.

dmd.backend.ty Compiler implementation of the D programming language.

dmd.backend.type Compiler implementation of the D programming language.

dmd.backend.util2 Compiler implementation of the D programming language.

dmd.backend.var Compiler implementation of the D programming language.

dmd.backend.xmm Compiler implementation of the D programming language.

dmd.root.aav Associative array implementation.

dmd.root.array Dynamic array implementation.

dmd.root.bitarray Implementation of a bit array.

dmd.root.ctfloat Collects functions for compile-time floating-point calculations.

dmd.root.file Read a file from disk and store it in memory.

dmd.root.filename Encapsulate path and file names.

dmd.root.hash Hash functions for arbitrary binary data.

dmd.root.longdouble 80-bit floating point value implementation if the C/D compiler does not support them natively.

dmd.root.man Open an online manual page.

dmd.root.outbuffer An expandable buffer in which you can write text or binary data.

dmd.root.port Portable routines for functions that have different implementations on different platforms.

dmd.root.region Region storage allocator implementation.

dmd.root.response Parse command line arguments from response files.

dmd.root.rmem Allocate memory using malloc or the GC depending on the configuration.

dmd.root.rootobject Provide the root object that classes in dmd inherit from.

dmd.root.speller Try to detect typos in identifiers.

dmd.root.string Contains various string related functions.

dmd.root.stringtable A specialized associative array with string keys stored in a variable length structure.

dmd.root.strtold Provides a D implementation of the standard C function strtold (String to long double).

dmd.access Enforce visibility contrains such as public and private.

dmd.aggregate Defines a Dsymbol representing an aggregate, which is a struct, union or class.

dmd.aliasthis Implements the alias this symbol.

dmd.apply A depth-first visitor for expressions.

dmd.argtypes_aarch64 Break down a D type into basic (register) types for the AArch64 ABI.

dmd.argtypes_sysv_x64 Break down a D type into basic (register) types for the x86_64 System V ABI.

dmd.argtypes_x86 Break down a D type into basic (register) types for the 32-bit x86 ABI.

dmd.arrayop Implement array operations, such as a[] = b[] + c[].

dmd.arraytypes Provide aliases for arrays of certain declarations or statements.

dmd.ast_node Defines the base class for all nodes which are part of the AST.

dmd.astbase Defines AST nodes for the parsing stage.

dmd.astcodegen Defines AST nodes for the code generation stage.

dmd.asttypename Development utility for printing AST nodes by their internal name, instead of as D source code.

dmd.attrib Defines declarations of various attributes.

dmd.blockexit Find out in what ways control flow can exit a statement block.

dmd.builtin Implement CTFE for intrinsic (builtin) functions.

dmd.canthrow Perform checks for nothrow.

dmd.chkformat Check the arguments to printf and scanf against the format string.

dmd.cli Defines the help texts for the CLI options offered by DMD.

dmd.clone Define the implicit opEquals, opAssign, post blit, copy constructor and destructor for structs.

dmd.compiler Describes a back-end compiler and implements compiler-specific actions.

dmd.complex Implements a complex number type.

dmd.cond Evaluate compile-time conditionals, such as static if version and debug.

dmd.console Control the various text mode attributes, such as color, when writing text to the console.

dmd.constfold Perform constant folding of arithmetic expressions.

dmd.cppmangle Do mangling for C++ linkage.

dmd.cppmanglewin Do mangling for C++ linkage for Digital Mars C++ and Microsoft Visual C++.

dmd.ctfeexpr CTFE for expressions involving pointers, slices, array concatenation etc.

dmd.ctorflow Manage flow analysis for constructors.

dmd.dcast Semantic analysis for cast-expressions.

dmd.dclass Defines a class declaration.

dmd.declaration Miscellaneous declarations, including typedef, alias, variable declarations including the implicit this declaration, type tuples, ClassInfo, ModuleInfo and various TypeInfos.

dmd.delegatize Implements conversion from expressions to delegates for lazy parameters.

dmd.denum Define enum declarations and enum members.

dmd.dimport A Dsymbol representing a renamed import.

dmd.dinifile Parses compiler settings from a .ini file.

dmd.dinterpret The entry point for CTFE.

dmd.dmacro Text macro processor for Ddoc.

dmd.dmangle Does name mangling for extern(D) symbols.

dmd.dmodule Defines a package and module.

dmd.dmsc Configures and initializes the backend.

dmd.doc Ddoc documentation generation.

dmd.dscope A scope as defined by curly braces {}.

dmd.dstruct Struct and union declarations.

dmd.dsymbol The base class for a D symbol, which can be a module, variable, function, enum, etc.

dmd.dsymbolsem Does the semantic 1 pass on the AST, which looks at symbol declarations but not initializers or function bodies.

dmd.dtemplate Defines TemplateDeclaration, TemplateInstance and a few utilities

dmd.dtoh This module contains the implementation of the C++ header generation available through the command line switch -Hc.

dmd.dversion Defines a Dsymbol for version = identifier and debug = identifier statements.

dmd.e2ir Converts expressions to Intermediate Representation (IR) for the backend.

dmd.eh Support for exception handling for EH_DM and EH_WIN32. Generate exception handling tables.

dmd.entity Defines the named entities to support the "\\&Entity;" escape sequence for strings / character literals.

dmd.env Functions for modifying environment variables.

dmd.errors Functions for raising errors.

dmd.escape Most of the logic to implement scoped pointers and scoped references is here.

dmd.expression Defines the bulk of the classes which represent the AST at the expression level.

dmd.expressionsem Semantic analysis of expressions.

dmd.filecache Cache the contents from files read from disk into memory.

dmd.foreachvar Utility to visit every variable in an expression.

dmd.frontend Contains high-level interfaces for interacting with DMD as a library.

dmd.func Defines a function declaration.

dmd.globals Stores command line options and contains other miscellaneous declarations.

dmd.glue Generate the object file for function declarations and critical sections.

dmd.gluelayer Declarations for back-end functions that the front-end invokes.

dmd.hdrgen Generate D interface files.

dmd.iasm Inline assembler for the D programming language compiler.

dmd.iasmdmd Inline assembler implementation for DMD.

dmd.iasmgcc Inline assembler for the GCC D compiler.

dmd.id Contains the Id struct with a list of predefined symbols the compiler knows about.

dmd.identifier Defines an identifier, which is the name of a Dsymbol.

dmd.impcnvtab Provides an implicit conversion table for basic types.

dmd.imphint Give import hints for common symbol names that couldn't be resolved.

dmd.init Defines initializers of variables, e.g. the array literal in int[3] x = [0, 1, 2].

dmd.initsem Semantic analysis of initializers.

dmd.inline Performs inlining, which is an optimization pass enabled with the -inline flag.

dmd.inlinecost Compute the cost of inlining a function call by counting expressions.

dmd.intrange Implement Value Range Propagation.

dmd.json Code for generating .json descriptions of the module when passing the -X flag to dmd.

dmd.lambdacomp Implements the serialization of a lambda function.

dmd.lexer Implements the lexical analyzer, which converts source code into lexical tokens.

dmd.lib A module defining an abstract library. Implementations for various formats are in separate libXXX.d modules.

dmd.libelf A library in the ELF format, used on Unix.

dmd.libomf A library in the OMF format, a legacy format for 32-bit Windows.

dmd.link Invoke the linker as a separate process.

dmd.mars Entry point for DMD.

dmd.mtype Defines a D type.

dmd.nogc Checks that a function marked @nogc does not invoke the Garbage Collector.

dmd.nspace A scoped C++ namespace symbol

dmd.ob Flow analysis for Ownership/Borrowing

dmd.objc Interfacing with Objective-C.

dmd.objc_glue Glue code for Objective-C interop.

dmd.opover Handles operator overloading.

dmd.optimize Perform constant folding.

dmd.parse Takes a token stream from the lexer, and parses it into an abstract syntax tree.

dmd.parsetimevisitor Defines a visitor for the AST.

dmd.permissivevisitor A visitor that facilitates the traversal of subsets of the AST.

dmd.printast Provides an AST printer for debugging.

dmd.s2ir Convert statements to Intermediate Representation (IR) for the back-end.

dmd.safe Checks whether member access or array casting is allowed in @safe code.

dmd.sapply Provides a depth-first statement visitor.

dmd.scanelf Extract symbols from an ELF object file.

dmd.scanomf Extract symbols from an OMF object file.

dmd.semantic2 Performs the semantic2 stage, which deals with initializer expressions.

dmd.semantic3 Performs the semantic3 stage, which deals with function bodies.

dmd.sideeffect Find side-effects of expressions.

dmd.statement Defines AST nodes for statements.

dmd.statement_rewrite_walker Provides a visitor for statements that allows rewriting the currently visited node.

dmd.statementsem Does semantic analysis for statements.

dmd.staticassert Defines the Dsymbol representing a static assert().

dmd.staticcond Lazily evaluate static conditions for static if, static assert and template constraints.

dmd.stmtstate Used to help transform statement AST into flow graph.

dmd.strictvisitor

dmd.target Handles target-specific parameters

dmd.templateparamsem Semantic analysis of template parameters.

dmd.tocsym Convert a D symbol to a symbol the linker understands (with mangled name).

dmd.toctype Convert a D type to a type the backend understands.

dmd.tocvdebug Generate debug info in the CV4 debug format.

dmd.todt Put initializers and objects created from CTFE into a dt_t data structure so the backend puts them into the data segment.

dmd.toir Convert to Intermediate Representation (IR) for the back-end.

dmd.tokens Defines lexical tokens.

dmd.toobj Convert an AST that went through all semantic phases into an object file.

dmd.traits Handle introspection functionality of the __traits() construct.

dmd.transitivevisitor

dmd.typesem Semantic analysis for D types.

dmd.typinf Generate TypeInfo objects, which are needed for run-time introspection of classes.

dmd.utf Functions related to UTF encoding.

dmd.utils This module defines some utility functions for DMD.

dmd.visitor Provides a visitor class visiting all AST nodes present in the compiler.

dmd.vsoptions When compiling on Windows with the Microsoft toolchain, try to detect the Visual Studio setup.

etc.c.odbc.sql Declarations for interfacing with the ODBC library.

etc.c.odbc.sqlext Declarations for interfacing with the ODBC library.

etc.c.odbc.sqltypes Declarations for interfacing with the ODBC library.

etc.c.odbc.sqlucode Declarations for interfacing with the ODBC library.

etc.c.curl This is an interface to the libcurl library.

gc.impl.conservative.gc Contains the garbage collector implementation.

gc.impl.manual.gc This module contains a minimal garbage collector implementation according to published requirements. This library is mostly intended to serve as an example, but it is usable in applications which do not rely on a garbage collector to clean up memory (ie. when dynamic array resizing is not used, and all memory allocated with 'new' is freed deterministically with 'delete').

gc.bits Contains a bitfield used by the GC.

gc.os Contains OS-level routines needed by the garbage collector.

gc.pooltable A sorted array to quickly lookup pools.

gc.proxy Contains the external GC interface.

rt.backtrace.dwarf Generates a human-readable stack-trace on POSIX targets using DWARF

rt.backtrace.elf This code reads ELF files and sections using memory mapped IO.

rt.backtrace.macho This module extracts debug info from the currently running Mach-O executable.

rt.util.container.array Array container for internal usage.

rt.util.container.common Common code for writing containers.

rt.util.container.hashtab HashTab container for internal usage.

rt.util.container.treap Treap container for internal usage.

rt.util.random Random number generators for internal usage.

rt.util.typeinfo This module contains utilities for TypeInfo implementation.

rt.util.utility Contains various utility functions used by the runtime implementation.

rt.aaA Implementation of associative arrays.

rt.aApply This code handles decoding UTF strings for foreach loops. There are 6 combinations of conversions between char, wchar, and dchar, and 2 of each of those.

rt.aApplyR This code handles decoding UTF strings for foreach_reverse loops. There are 6 combinations of conversions between char, wchar, and dchar, and 2 of each of those.

rt.adi Implementation of dynamic array property support routines.

rt.alloca Implementation of alloca() standard C routine.

rt.arrayassign Implementation of array assignment support routines.

rt.arraycat Implementation of array copy support routines.

rt.cast_ Implementation of array assignment support routines.

rt.cmath2 Runtime support for complex arithmetic code generation (for Posix).

rt.config Configuration options for druntime.

rt.cover Implementation of code coverage analyzer.

rt.critical_ Implementation of support routines for synchronized blocks.

rt.deh Implementation of exception handling support routines.

rt.deh_win32 Implementation of exception handling support routines for Win32.

rt.deh_win64_posix Written in the D programming language. Implementation of exception handling support routines for Posix and Win64.

rt.dmain2 Contains druntime startup and shutdown routines.

rt.dwarfeh Exception handling support for Dwarf-style portable exceptions.

rt.ehalloc Exception allocation, cloning, and release compiler support routines.

rt.lifetime This module contains all functions related to an object's lifetime: allocation, resizing, deallocation, and finalization.

rt.llmath Support for 64-bit longs.

rt.memory This module tells the garbage collector about the static data and bss segments, so the GC can scan them for roots. It does not deal with thread local static data.

rt.memset Contains a memset implementation used by compiler-generated code.

rt.minfo Written in the D programming language. Module initialization routines.

rt.monitor_ Contains the implementation for object monitors.

rt.qsort This is a public domain version of qsort.d. All it does is call C's qsort().

rt.sections

rt.sections_android Written in the D programming language. This module provides bionic-specific support for sections.

rt.sections_darwin_64 Written in the D programming language. This module provides Darwin 64 bit specific support for sections.

rt.sections_elf_shared Written in the D programming language. This module provides ELF-specific support for sections with shared libraries.

rt.sections_osx_x86 Written in the D programming language. This module provides OS X x86 specific support for sections.

rt.sections_osx_x86_64 Written in the D programming language. This module provides OS X x86-64 specific support for sections.

rt.sections_solaris Written in the D programming language. This module provides Solaris-specific support for sections.

rt.sections_win32 Written in the D programming language. This module provides Win32-specific support for sections.

rt.sections_win64 Written in the D programming language. This module provides Win32-specific support for sections.

rt.tlsgc

rt.trace Contains support code for code profiling.

rt.tracegc Contains implementations of functions called when the -profile=gc switch is thrown.

rt.unwind Written in the D programming language. Equivalent to unwind.h

object Forms the symbols available to all D programs. Includes Object, which is the root of the class object hierarchy. This module is implicitly imported.

std Convenience file that allows to import entire Phobos in one import.

Access to plattform libraries is supported by specific D header files.

	D header files
C99	`core.stdc.assert_` `core.stdc.complex` `core.stdc.ctype` `core.stdc.errno` `core.stdc.fenv` `core.stdc.float_` `core.stdc.inttypes` `core.stdc.limits` `core.stdc.locale` `core.stdc.math` `core.stdc.signal` `core.stdc.stdarg` `core.stdc.stddef` `core.stdc.stdint` `core.stdc.stdio` `core.stdc.stdlib` `core.stdc.string` `core.stdc.tgmath` `core.stdc.time` `core.stdc.wchar_` `core.stdc.wctype`
Posix
Windows
GNU/Linux
FreeBSD
OSX
Solaris

Deprecated D header files.

	D header files
C

API Documentation

API documentation

Assembling Your Own Allocator