Can I run D online without installing it?

Yes. CompileBytes compiles and runs your D programs on the server, so you can try the language directly in an isolated hosted runtime without installing a D compiler or toolchain.

Which D compiler and version are used?

Programs are built with GDC, the GCC-based D compiler. The reported version 10.2.0 corresponds to the GCC toolchain it is part of; GDC implements the D language frontend.

How do I read input from stdin in D?

Use readln() to read a line, or readf for formatted input, both from std.stdio. Data you enter in the stdin box is delivered to your program through standard input.

Yes. The D language and its compilers, including GDC, are free and open source, and using D here on CompileBytes costs nothing.

Does D have garbage collection?

Yes, D uses garbage collection by default for memory safety and convenience, but it also supports manual memory management and can run with @nogc code when you need full control over allocations.

Online D Compiler & Playground

1 file

Tap Run to execute

main.d · output appears here

main.d

Press Run to execute

Output streams here as your program runs.

D 1.26.0Readymain.dLn 1, Col 1Spaces: 4UTF-8

About the D playground

D is a compiled systems programming language that aims to combine the performance and low-level control of C and C++ with the productivity of modern, higher-level languages. It offers strong static typing, garbage collection (which you can opt out of), templates, compile-time function execution, and clean module-based organization. CompileBytes builds D programs with GDC, the GCC-based D compiler; the reported version 10.2.0 reflects the GCC toolchain it ships with.

D programs start at a main function and use a familiar C-like syntax, so C and C++ programmers feel at home quickly. Beyond the basics, D provides ranges, slices, contract programming, and powerful metaprogramming via templates and mixins. Its standard library, Phobos, covers algorithms, ranges, I/O, and more, making D suitable for everything from quick scripts to high-performance applications.

1.26.0D runtime

main.dentry file

projectworkspace

stdinprogram input

How it works

Write

main.d is the entry point. Add helper files from the explorer and import them into your project.

Give it input

Use the Input panel to pipe standard input to your program when it needs data.

Run

Run sends your code to a fresh hosted runtime and streams the result into the output panel.

Keep or share

Your draft stays in this browser, and Share creates a separate snapshot link.

External resources

dlang.org— Official website
GitHub— Official source repository

Two-file project

main.d imports answer from the sibling helper module.

main.d

module main;

import std.stdio;
import helper : answer;

void main() {
    writeln(answer());
}

helper.d

module helper;

int answer() {
    return 42;
}

Hello, World

import std.stdio;

void main() {
    writeln("Hello, World!");
}

A function

import std.stdio;

int square(int n) {
    return n * n;
}

void main() {
    writeln(square(7));
}

A loop

import std.stdio;

void main() {
    foreach (i; 1 .. 6) {
        writeln(i, " squared is ", i * i);
    }
}

Arrays and ranges

import std.stdio;
import std.algorithm;
import std.array;

void main() {
    int[] nums = [1, 2, 3, 4, 5];
    auto evens = nums.filter!(n => n % 2 == 0).array;
    auto total = nums.sum;
    writeln("evens: ", evens);
    writeln("sum: ", total);
}

Struct with a method

import std.stdio;

struct Point {
    int x;
    int y;

    int manhattan() {
        import std.math : abs;
        return abs(x) + abs(y);
    }
}

void main() {
    auto p = Point(3, -4);
    writeln("distance: ", p.manhattan());
}

Associative array

import std.stdio;

void main() {
    int[string] counts;
    foreach (word; ["a", "b", "a", "c", "b", "a"]) {
        counts[word]++;
    }
    foreach (key, value; counts) {
        writeln(key, ": ", value);
    }
}

Reading input

import std.stdio;
import std.string;

void main() {
    write("Enter your name: ");
    string name = readln().strip();
    writeln("Hello, ", name, "!");
}

Class and interface

import std.stdio;

interface Shape {
    double area();
}

class Circle : Shape {
    double r;
    this(double r) { this.r = r; }
    double area() { return 3.14159 * r * r; }
}

void main() {
    Shape s = new Circle(2.0);
    writeln("area: ", s.area());
}

Template function

import std.stdio;

T maxOf(T)(T a, T b) {
    return a > b ? a : b;
}

void main() {
    writeln(maxOf(3, 9));
    writeln(maxOf(2.5, 1.5));
}

Map and reduce

import std.stdio;
import std.algorithm;

void main() {
    int[] nums = [1, 2, 3, 4, 5];
    auto doubled = nums.map!(x => x * 2);
    auto total = nums.reduce!((a, b) => a + b);
    writeln(doubled);
    writeln("total: ", total);
}

Editor guide

The editor uses Monaco, the engine behind VS Code, with language-aware editing tools and familiar keyboard controls.

Getting started

Type or paste your code into the editor, then click Run (or press Ctrl/Cmd + Enter) to execute it.

Output streams into the console panel, including runtime errors, exit status, and execution time.

Nothing to install and no account to create — code runs in an isolated hosted runtime.

A full-featured code editor

Language-aware autocomplete and IntelliSense suggestions where the editor has a matching language service

Syntax highlighting, with native compiler and runtime errors shown in the console

Bracket matching, auto-indentation, code folding, and a minimap

Multi-cursor editing plus find & replace (Ctrl/Cmd + F)

Full undo/redo history and copy to clipboard

Built on Monaco — the same editor that powers VS Code

Running & testing your code

Run on demand, or turn on Auto-run to execute on every change

Stop long-running or infinite programs at any time

A real console shows standard output, errors, exit status, and execution time

Program input

Pass standard input (stdin) to your program from the Input panel — one value per line

Make it yours

Switch between light and dark themes

Adjust font size and other editor settings

Toggle side-by-side or top/bottom layouts

Enter distraction-free fullscreen mode

Share & save

Generate a shareable link to your exact code in one click — no login needed

Your work autosaves to your browser, so you can pick up where you left off

Copy the active file to your clipboard

Handy keyboard shortcuts

Run code: Ctrl/Cmd + Enter

Find & replace: Ctrl/Cmd + F

Open the full shortcut list from the keyboard icon in the toolbar

D project files

D is one of 23 linked-project compilers. Run always starts main.d; selecting a helper tab changes what you edit, not the entry file.

main.d imports answer from the sibling helper module.

Linked-project languages (23): Node.js, TypeScript, Deno, Python, C, Go, Dart, Swift, Rust, Ruby, PHP, Java, Kotlin, C++, C#, Nim, Crystal, Haxe, Zig, Scala, D, Bun, Objective-C.

Single-file scratchpads (46): Matplotlib, NumPy, pandas, Haskell, Clojure, Perl, Lua, Tcl, jq, Raku, Elixir, Bash, Zsh, Nushell, R, Assembly (NASM), Julia, Octave, Groovy, PowerShell, Visual Basic .NET, Odin, Pascal, Lisp, Erlang, CoffeeScript, COBOL, BASIC, V, Racket, OCaml, Prolog, AWK, Emacs Lisp, Emojicode, Forth, F#, Fortran, Assembly (NASM64), Solidity, Mojo, Ada, WASM (WAT), Gleam, Shell Script (sh), Scheme. Their extra project files are not submitted to the runtime.

Download

Download project exports every D tab and a README in one ZIP archive.

Every shortcut, searchable:

D

D Playground

Write

Give it input

Run

Keep or share

Two-file project

Run

Editing

Navigation

Selection

Terminal