Home - D Programming Language (original) (raw)

D is a general-purpose programming language with static typing, systems-level access, and C-like syntax. With the D Programming Language, write fast, read fast, and run fast.

Fast code, fast.

your code here

Got a brief example illustrating D?

Submit your code to the digitalmars.D forum specifying "[your code here]" in the subject.

Upon approval it will be showcased here on a random schedule.

Support the D language

D is made possible through the hard work and dedication of many volunteers, with the coordination and outreach of the D Language Foundation, a 501(c)(3) non-profit organization. You can help further the development of the D language and help grow our community by supporting the Foundation.

Run

Configure linting, formatting or completion for your favorite IDE,editor or use run.dlang.io to play and experiment with D code.

Fast code, fast.

Write Fast

D allows writing large code fragments without redundantly specifying types, like dynamic languages do. On the other hand, static inference deduces types and other code properties, giving the best of both the static and the dynamic worlds.

void main() { auto arr = [ 1, 2, 3.14, 5.1, 6 ]; auto dictionary = [ "one" : 1, "two" : 2, "three" : 3 ]; auto x = min(arr[0], dictionary["two"]); } auto min(T1, T2)(T1 lhs, T2 rhs) { return rhs < lhs ? rhs : lhs; }

Automatic memory management makes for safe, simple, and robust code. D also supports scoped resource management (aka theRAII idiom) and scope statements for deterministic transactional code that is easy to write and read.

import std.stdio;

class Widget { }

void main() { auto w = new Widget; scope(exit) { writeln("Exiting main."); } foreach (line; File(FILE_FULL_PATH).byLine()) { writeln(line); } writeln(); }

Built-in linear and associative arrays, slices, and ranges make daily programming simple and pleasant for tasks, both small and large.

The D programming language Modern convenience. Modeling power. Native efficiency.

void main() { import std.range, std.stdio;

auto sum = 0.0;
auto count = stdin.byLine
    .tee!(l => sum += l.length).walkLength;

writeln("Average line length: ",
    count ? sum / count : 0);

}

Read Fast

The best paradigm is to not impose something at the expense of others. D offers classic polymorphism, value semantics, functional style, generics, generative programming, contract programming, and more—all harmoniously integrated.

interface Printable { void print(uint level) in { assert(level > 0); } }

class Widget : Printable { void print(uint level) in{ } do{ } }

class ExtendedWidget : Widget { override void print(uint level) in { } do { } }

immutable string programName = "demo"; int perThread = 42; shared int perApp = 5;

struct BigNum { this(this) { } ~this() { } }

void main() { }

D offers an innovative approach to concurrency, featuring true immutable data, message passing, no sharing by default, and controlled mutable sharing across threads. Read more.

From simple scripts to large projects, D has the breadth to scale with any application's needs: unit testing, information hiding, refined modularity, fast compilation, precise interfaces. Read more.

Run Fast

D compiles naturally to efficient native code.

D is designed such that most "obvious" code is fast _and_safe. On occasion a function might need to escape the confines of type safety for ultimate speed and control. For such rare cases D offers native pointers, type casts, access to any C function without any intervening translation, manual memory management, custom allocators and even inline assembly code.

import core.stdc.stdlib;

void livingDangerously() { enum bytes = float.sizeof * 1024 * 1024; auto buf = malloc(bytes); scope(exit) free(buf); auto floats = cast(float[]) buf[0 .. bytes]; auto moreBuf = alloca(4096 * 100); }

uint checked_multiply(uint x, uint y) { uint result; version (D_InlineAsm_X86) { asm { mov EAX,x ; mul EAX,y ; mov result,EAX ; jc Loverflow ; } return result; } else { result = x * y; if (!y || x <= uint.max / y) return result; } Loverflow: throw new Exception("multiply overflow"); }

void main() { }

The @safe, @trusted, and @system function attributes allow the programmer to best decide the safety-efficiency tradeoffs of an application, and have the compiler check for consistency. Read more.