Languages

Ada is a standardized, strongly typed systems language for long-lived, embedded, real-time, and high-integrity software where explicit contracts, packages, tasking, and analyzability matter.

• active
• static
• imperative
• procedural

Runtime

ahead-of-time native compilation through implementation-specific runtimes, from full Ada tasking runtimes to restricted embedded and certifiable runtimes

Memory

deterministic stack and object lifetimes, access types, controlled types, optional dynamic allocation, and restricted profiles for high-integrity subsets

Tooling

GNAT, GPRbuild, Alire

Open Ada

C is a standardized systems programming language for native interfaces, operating-system and embedded work, language runtimes, and portable low-level libraries where explicit memory, layout, and ABI control matter.

• active
• static
• procedural
• imperative

Runtime

native code through hosted or freestanding implementations with no required garbage collector

Memory

manual memory management with automatic, static, allocated, and implementation-defined storage

Tooling

Conan, vcpkg, pkg-config

Open C

C++ is a standardized, multi-paradigm systems language for performance-critical native software, large C++ codebases, game engines, embedded application layers, libraries, and domains where zero-overhead abstractions and direct control must coexist.

• active
• static
• systems
• object-oriented

Runtime

native code through implementation-defined compilers, standard libraries, ABIs, and optional runtime features

Memory

deterministic object lifetimes, RAII, smart pointers, value semantics, and manual escape hatches

Tooling

Conan, vcpkg, CMake

Open C++

Dart is a Google-developed, soundly typed application language built around the Dart VM, ahead-of-time native compilation, JavaScript and WebAssembly web compilation, and Flutter's multi-platform UI framework.

• active
• static
• object-oriented
• imperative

Runtime

Dart VM with JIT for development, AOT native compilation for production, JavaScript or WebAssembly for web targets

Memory

managed by the Dart runtime garbage collector

Tooling

pub, pub.dev, Flutter SDK

Open Dart

MicroPython is a compact Python 3 implementation for microcontrollers and constrained systems, centered on interactive hardware control, a Python subset, board-specific ports, the machine module, mpremote workflows, and careful memory and compatibility tradeoffs.

• active
• dynamic
• procedural
• object-oriented

Runtime

compact Python compiler and virtual machine running on bare-metal microcontrollers, RTOS ports, Unix, Windows, WebAssembly, and other ports

Memory

garbage collected heap with constrained RAM, stack, flash, and port-specific allocation behavior

Tooling

mip, mpremote, micropython-lib

Open MicroPython

Rust is a statically typed systems language for software that needs low-level control, predictable performance, and strong compile-time memory and concurrency checks without a required garbage collector.

• active
• static
• systems
• multi-paradigm

Runtime

native binaries with a small standard runtime; no required garbage collector

Memory

ownership, borrowing, lifetimes, and RAII without a required garbage collector

Tooling

Cargo, crates.io, rustup

Open Rust

Scheme is a small, standardized Lisp-family language for teaching, language research, interpreters, compilers, embedded extension systems, and careful functional programming where lexical scope, proper tail calls, hygienic macros, and continuations matter.

• active
• dynamic
• lisp
• functional

Runtime

many implementations across interpreters, bytecode systems, native-code compilers, embeddable runtimes, R5RS/R6RS/R7RS modes, and implementation-specific extensions

Memory

automatic memory management in each implementation, normally garbage-collected, with mutable pairs, strings, vectors, bytevectors, and implementation-specific controls for foreign memory or embedding

Tooling

SRFIs, implementation libraries, OS packages

Open Scheme

Zig is a pre-1.0 systems programming language and toolchain for explicit memory management, C interoperability, cross-compilation, small native binaries, and low-level software that wants more structure than C without Rust-style ownership checking.

• active
• static
• systems
• procedural

Runtime

ahead-of-time native compilation through the Zig toolchain with no required garbage collector or language runtime

Memory

manual memory management with explicit allocator parameters by convention and no default language-level allocator

Tooling

Zig Build System, build.zig.zon, zig fetch

Open Zig