# D

> multi-paradigm system programming language

**Wikidata**: [Q319268](https://www.wikidata.org/wiki/Q319268)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/D_(programming_language))  
**Source**: https://4ort.xyz/entity/d

## Summary

D is a software application influenced by C++, Java, and Python.

## Summary
D is a multi-paradigm system programming language designed for high performance and modern software development. Created by Walter Bright and first released in 2001, it combines features from imperative, object-oriented, functional, and concurrent programming paradigms while offering static typing and compile-time efficiency.

## Key Facts
- **Inception**: First released on December 8, 2001.
- **Creator**: Designed by Walter Bright, an American software developer known for compiler design.
- **Paradigms**: Supports imperative, object-oriented, functional, and concurrent programming.
- **Typing Discipline**: Features static, strong, and inference typing.
- **Compilation**: A compiled language with a reference implementation called DMD (D Reference Compiler).
- **Versions**: Stable releases include 2.094.2 (2020), 2.095.0 (2021), and 2.100.0 (2022).
- **Influences**: Inspired by C++, Java, Python, and other languages.
- **File Extensions**: Uses `.d`, `.dd`, `.di`, and `.def` for source code.
- **Mascot**: Represented by "D-Man," the official mascot.
- **Website**: Official site at [dlang.org](https://dlang.org).

## FAQs
### Q: What is D used for?
A: D is a system programming language used for high-performance applications, including backend services, game development, and embedded systems. It competes with languages like C++, Rust, and Go.

### Q: Who created D?
A: D was designed by Walter Bright, an American engineer and compiler developer, with contributions from the D Language Foundation.

### Q: Is D a compiled or interpreted language?
A: D is a compiled language, meaning source code is translated into machine-executable binaries before runtime.

### Q: What programming paradigms does D support?
A: D supports multiple paradigms, including imperative, object-oriented, functional, and concurrent programming.

### Q: How does D compare to C++?
A: D is a modern alternative to C++ with similar performance but added features like memory safety, garbage collection, and simpler syntax.

## Why It Matters
D addresses the complexity and safety issues of traditional systems programming languages like C and C++ while maintaining high performance. Its multi-paradigm design allows developers to choose the best approach for their task, whether procedural, object-oriented, or functional. By combining modern features like garbage collection, compile-time function execution, and concurrent programming support, D reduces development time without sacrificing efficiency. It is particularly valuable in domains requiring both low-level control and high-level abstractions, such as game engines, operating systems, and high-frequency trading platforms. As a statically typed, compiled language, D also ensures runtime efficiency, making it a strong contender in performance-critical applications.

## Notable For
- **Multi-Paradigm Design**: Integrates imperative, object-oriented, functional, and concurrent programming in a single language.
- **Performance**: Offers near-native speed with modern compiler optimizations.
- **Memory Safety**: Includes garbage collection and manual memory management options.
- **Compile-Time Features**: Supports compile-time function execution (CTFE) and metaprogramming.
- **Backward Compatibility**: Designed to interoperate with C and C++ libraries seamlessly.

## Body
### Overview
D is a general-purpose programming language emphasizing performance, safety, and expressive power. It was created by Walter Bright, who began development in 1999 and released the first version in December 2001. The language is maintained by the D Language Foundation and has a reference compiler, DMD.

### Programming Paradigms
D supports multiple paradigms:
- **Imperative**: Traditional procedural programming with statements and loops.
- **Object-Oriented**: Classes, inheritance, and polymorphism.
- **Functional**: First-class functions, lambdas, and immutability.
- **Concurrent**: Built-in support for parallelism and threading.

### Technical Features
- **Static Typing**: Type checking at compile time for performance and safety.
- **Garbage Collection**: Automatic memory management with optional manual control.
- **Metaprogramming**: Templates and compile-time function execution (CTFE).
- **Interoperability**: Direct compatibility with C and C++ libraries.

### Versions and Development
D has undergone continuous development, with major stable releases including:
- **2.094.2** (November 2020)
- **2.095.0** (January 2021)
- **2.100.0** (May 2022)

The language is actively maintained, with updates focusing on performance, tooling, and standard library improvements.

### Competitors and Alternatives
D competes with other systems programming languages:
- **C++**: A direct alternative with similar performance but more complex syntax.
- **Rust**: Focuses on memory safety without garbage collection.
- **Go**: Emphasizes simplicity and concurrency for backend services.
- **Java**: Used for enterprise applications but lacks low-level control.

### Community and Resources
- **Official Website**: [dlang.org](https://dlang.org)
- **Online Compiler**: [run.dlang.io](https://run.dlang.io/)
- **Documentation**: Comprehensive guides and tutorials available on the official site.
- **GitHub**: Active repositories under topics like `d`, `dlang`, and `d-language`.

## Schema Markup
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "D",
  "description": "Multi-paradigm system programming language designed for high performance and modern software development.",
  "url": "https://dlang.org",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q206855",
    "https://en.wikipedia.org/wiki/D_(programming_language)"
  ],
  "additionalType": "ProgrammingLanguage"
}

## References

1. [Source](https://github.com/JohnMarkOckerbloom/ftl/blob/master/data/wikimap)
2. [Change Log: 2.094.2. 2020](https://dlang.org/changelog/2.094.2.html)
3. [Change Log: 2.095.0](https://dlang.org/changelog/2.095.0.html)
4. [Change Log: 2.095.1](https://dlang.org/changelog/2.095.1.html)
5. [Change Log: 2.096.0](https://dlang.org/changelog/2.096.0.html)
6. [Change Log: 2.097.0](https://dlang.org/changelog/2.097.0.html)
7. [Source](https://dlang.org/changelog/2.098.0.html)
8. [Source](https://dlang.org/changelog/2.098.1.html)
9. [Source](https://dlang.org/changelog/2.099.1.html)
10. [Source](https://dlang.org/changelog/2.100.0.html)
11. [Source](https://dlang.org/changelog/2.100.1.html)
12. [Source](https://dlang.org/changelog/2.100.2.html)
13. [Change Log: 2.101.1](https://dlang.org/changelog/2.101.1.html)
14. [Change Log: 2.102.1](https://dlang.org/changelog/2.102.1.html)
15. [Change Log: 2.104.0](https://dlang.org/changelog/2.104.0.html)
16. [Change Log: 2.104.1](https://dlang.org/changelog/2.104.1.html)
17. [2.104.2](https://dlang.org/changelog/2.104.2.html)
18. [2.105.0](https://dlang.org/changelog/2.105.0.html)
19. [2.105.1](https://dlang.org/changelog/2.105.1.html)
20. [2.105.2](https://dlang.org/changelog/2.105.2.html)
21. [2.105.3](https://dlang.org/changelog/2.105.3.html)
22. [2.106.0](https://dlang.org/changelog/2.106.0.html)
23. [2.106.1](https://dlang.org/changelog/2.106.1.html)
24. [2.107.0](https://dlang.org/changelog/2.107.0.html)
25. [2.107.1](https://dlang.org/changelog/2.107.1.html)
26. [2.108.0](https://dlang.org/changelog/2.108.0.html)
27. [2.108.1](https://dlang.org/changelog/2.108.1.html)
28. [2.109.0](https://dlang.org/changelog/2.109.0.html)
29. [2.109.1](https://dlang.org/changelog/2.109.1.html)
30. [Change Log: 2.110.0. 2025](https://dlang.org/changelog/2.110.0.html)
31. [Change Log: 2.111.0. 2025](https://dlang.org/changelog/2.111.0.html)
32. [Change Log: 2.112.0. 2026](https://dlang.org/changelog/2.112.0.html)
33. Freebase Data Dumps. 2013
34. Integrated Authority File
35. National Library of Israel