You already know C.Now explore other languages.

C reimagined for the networked world. Go keeps C's simplicity and compile speed while adding goroutines, garbage collection, and a standard library built for servers and CLIs.

• Goroutines — thousands of concurrent tasks at ~2 KB each; C threads cost megabytes and require pthreads boilerplate
• Garbage collection — no malloc/free, no use-after-free, no double-free; the GC handles memory without a runtime you have to ship
• Interfaces without headers — define the methods, satisfy the interface; no vtable declarations, no forward declarations
• Error values instead of errno — functions return (result, error) pairs; no global state, no setjmp/longjmp
• Compiles a full program in seconds, produces a single static binary with no shared-library dependencies
• Direct C interop via cgo — call any C function or link any C library from Go code

What C programmers reach for when they want to stop managing memory. Ruby's runtime handles everything C makes you do by hand — strings as objects, arrays that resize themselves, a garbage-collected heap — freeing you to describe the problem instead of the machine that solves it.

• Garbage collection — no malloc, no free, no use-after-free; memory is managed for you
• Strings as first-class objects — .upcase, .split, .gsub built in; no null terminator to track
• Dynamic typing — no type declarations; variables hold any object at any time
• Blocks and closures — pass behavior the way C passes function pointers, but with lexical scope captured automatically
• Open classes — add methods to any class, including built-ins like Integer and String, at runtime

C's speed and control, with memory safety enforced by the compiler. Rust eliminates use-after-free, buffer overruns, and data races — at compile time, with no garbage collector and no runtime overhead.

• Ownership and borrowing — the compiler proves memory safety; the bugs C programmers lose weeks to (UAF, dangling pointers, data races) are compile errors
• No undefined behavior — out-of-bounds, integer overflow, and null dereferences that silently corrupt C programs are caught at compile time or checked in debug builds
• Zero-cost abstractions — iterators, generics, and traits compile to the same assembly as hand-written C; you pay for what you use
• Result and Option replace errno, NULL returns, and setjmp — every error path is explicit and the compiler enforces handling it
• Pattern matching with exhaustive match — no fallthrough, no missed cases, destructuring of any type
• Drop-in C interop — extern "C" and #[repr(C)] let you replace individual C files in an existing project one at a time

What C would look like if designed today. Zig keeps C's simplicity and direct hardware access while replacing the preprocessor, adding explicit allocators, and making every error path visible in the type system.

• Comptime replaces the C preprocessor — type-safe, debuggable metaprogramming using ordinary Zig code; no macro pitfalls, no token pasting
• Explicit allocators — every function that allocates takes an allocator parameter; swap malloc for an arena or stack allocator without touching library code
• Error unions (!T) — every error path is visible in the return type; no unchecked errno, no silent failures, exhaustive handling enforced by the compiler
• No undefined behavior in safe modes — integer overflow, out-of-bounds access, and null dereference that silently corrupt C programs are caught at runtime in debug builds
• @cImport — import any C header directly; use existing C libraries without writing manual bindings
• C ABI compatible — replace individual C files in an existing project one at a time; Zig and C objects link together without ceremony

C with a full systems-programming tower on top. C++ adds classes, templates, RAII, and the STL while staying zero-overhead and fully compatible with every C library and C ABI you already use.

• Full binary compatibility — every C header, library, and ABI works unchanged; C++ is a strict superset of C for linking purposes
• Classes and virtual dispatch — OOP built directly on top of C structs; a class is a struct with methods and access control
• Templates — generic code resolved entirely at compile time; no boxing, no type erasure, no runtime overhead
• RAII and smart pointers (unique_ptr, shared_ptr) — deterministic resource cleanup replacing manual free() and fclose()
• The STL: vector, map, sort, transform, ranges — type-safe, zero-overhead containers and algorithms replacing your hand-rolled C equivalents
• Modern C++23: std::format, structured bindings, std::optional, std::expected — ergonomics that close the gap with higher-level languages

What C could have grown into. D keeps C's performance and low-level access while adding a module system, garbage collection, ranges, built-in unit tests, and a metaprogramming system that replaces the preprocessor — without dragging in C++'s complexity.

• Module system replaces headers — no #include, no header guards, no order-of-declaration rules; each file is a self-contained module
• Garbage collected by default, manual memory available — everyday code needs no malloc/free; @nogc lets you opt out completely for hot paths
• UFCS (Universal Function Call Syntax) — strlen(s) and s.strlen() are identical; method chaining without C++ class machinery
• Ranges and std.algorithm — lazy, composable iteration (filter, map, sort) replacing hand-written C loops
• Built-in unittest blocks and contract programming (in/out/invariant) — testing and precondition checking without an external framework
• Direct C interop — link any C library, call any C function with extern(C); the C standard library is available as core.stdc.*