ABAP is SAP's business application language for SAP systems, custom extensions, reports, data-intensive transaction logic, SAP NetWeaver and ABAP Platform applications, and cloud-ready SAP extensions through ABAP Cloud and RAP.
- active
- static with dynamic features
- procedural
- object-oriented
- Runtime
- ABAP source is activated into platform-independent byte code and executed by the ABAP runtime on SAP NetWeaver Application Server for ABAP, ABAP Platform, SAP BTP ABAP environment, or SAP S/4HANA ABAP environments
- Memory
- ABAP runtime-managed data objects, internal sessions, internal tables, object references, database result sets, and SAP application-server resources rather than manual heap allocation
- Tooling
- ABAP packages, Change and Transport System, ABAP Development Tools
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
Assembly language is a family of target-specific low-level languages that express machine instructions, registers, labels, directives, and ABI contracts close to the processor and object format.
- active
- target-specific
- low-level
- imperative
- Runtime
- assembled to machine code and linked or loaded for a specific instruction set, object format, operating system, firmware image, or bare-metal target
- Memory
- direct address, register, stack, and memory access according to the processor architecture, privilege level, and ABI
- Tooling
- GNU Binutils, NASM, MASM
Bash is GNU's Bourne-style shell and command language, used both interactively and as a scripting layer around Unix processes, files, pipelines, environment variables, and standard utilities.
- active
- dynamic
- command language
- imperative
- Runtime
- interpreted by a shell process that expands commands, applies redirections, manages jobs, and launches builtins, functions, or external programs
- Memory
- managed by the shell process and external commands; scripts normally coordinate processes rather than allocate memory directly
- Tooling
- Varies by ecosystem
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
C# is a statically typed, managed language centered on .NET, used for backend services, enterprise applications, Windows and cross-platform desktop apps, Unity games, cloud workloads, and tooling.
- active
- static
- object-oriented
- imperative
- Runtime
- .NET runtime and Common Language Runtime execution model
- Memory
- garbage collected managed heap with value types, spans, disposal patterns, and unsafe interop escape hatches
- Tooling
- NuGet, dotnet CLI, MSBuild
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
CFML is a tag-and-script server-side web language best known through Adobe ColdFusion and Lucee, used for database-backed web applications, intranet systems, forms, reports, and long-lived JVM-hosted business apps.
- active
- dynamic
- server-side scripting
- tag-based programming
- Runtime
- CFML source compiled or interpreted by engines such as Adobe ColdFusion or Lucee, commonly running on the JVM inside an application server, servlet container, or bundled server distribution
- Memory
- managed by the CFML engine and JVM, with request, session, application, server, cache, database, and Java object lifetimes controlled by application configuration and engine behavior
- Tooling
- ColdFusion Package Manager, CommandBox, ForgeBox
COBOL is a standardized compiled language for business data processing, high-volume records, decimal arithmetic, reports, batch jobs, and long-lived mainframe systems where correctness and continuity matter more than novelty.
- active
- static
- procedural
- imperative
- Runtime
- compiled to target-specific native code, managed COBOL runtimes, or intermediate forms depending on compiler, platform, and deployment target
- Memory
- statically described records, working storage, linkage data, files, tables, and implementation-managed runtime storage rather than a garbage-collected object heap
- Tooling
- IBM Enterprise COBOL, GnuCOBOL, OpenText Visual COBOL
Clojure is a dynamically typed, functional Lisp for the JVM, centered on immutable persistent data structures, Java interoperability, REPL-driven development, macros, controlled state, and pragmatic use of the Java ecosystem.
- active
- dynamic
- functional
- lisp
- Runtime
- compiled on load to JVM bytecode, with optional ahead-of-time compilation and host variants such as ClojureScript and ClojureCLR
- Memory
- automatic memory management on the JVM, with immutable persistent collections and controlled mutable references through vars, atoms, refs, and agents
- Tooling
- Clojure CLI, tools.deps, tools.build
Common Lisp is an ANSI-standardized Lisp for symbolic systems, interactive development, macro-heavy abstraction, CLOS object modeling, and long-lived applications where a mature dynamic language and implementation-specific deployment tradeoffs fit.
- active
- dynamic
- lisp
- functional
- Runtime
- multiple ANSI Common Lisp implementations, commonly interactive and compiled, with SBCL as a widely used open source native-code implementation and other open source and commercial implementations available
- Memory
- automatic memory management in each implementation, normally garbage-collected, with implementation-specific controls for allocation, images, foreign memory, threads, and runtime tuning
- Tooling
- ASDF, Quicklisp, implementation libraries
Crystal is a statically typed, Ruby-inspired compiled language for native tools, web backends, C-adjacent applications, and scripts that benefit from Ruby-like syntax, type inference, native executables, fibers, channels, macros, and Shards.
- active
- static
- object-oriented
- imperative
- Runtime
- ahead-of-time native compilation through the Crystal compiler and LLVM, with a runtime for garbage collection, fibers, channels, I/O scheduling, and standard-library services
- Memory
- automatic garbage collection for heap-allocated reference types, with explicit care still required for C-managed resources and finalizers
- Tooling
- Shards, crystal build, crystal run
D is a C and C++ adjacent systems programming language with native compilation, garbage collection by default, templates, compile-time function execution, ranges, @safe/@trusted/@system safety attributes, DUB packages, Phobos, and the DMD, LDC, and GDC compiler families.
- active
- static
- systems
- imperative
- Runtime
- ahead-of-time native compilation through DMD, LDC, or GDC, with a D runtime and standard library in ordinary builds plus C and C++ interop for native boundaries
- Memory
- garbage collected by default, with RAII, scope guards, @nogc functions, manual allocation, C interop, and @safe/@trusted/@system attributes for memory-safety boundaries
- Tooling
- DUB, dub build, dub test
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
Delphi is a commercial Object Pascal language and RAD toolchain centered on native desktop, mobile, database, and business applications, with its strongest fit in long-lived Windows VCL codebases, cross-platform FireMonkey apps, and Delphi maintenance work.
- active
- static
- object-oriented
- imperative
- Runtime
- ahead-of-time native compilation through Delphi compilers, RAD Studio project tooling, the RTL, and optional VCL, FireMonkey, and package runtimes
- Memory
- manual object ownership with constructors and destructors, automatic management for strings, dynamic arrays, variants, and interfaces, plus platform-specific memory managers
- Tooling
- GetIt Package Manager, Delphi packages, Lazarus Package Manager
Elixir is a dynamically typed, functional language for the Erlang VM, centered on lightweight BEAM processes, OTP supervision, message passing, Mix and Hex tooling, Erlang interoperability, and Phoenix web applications.
- active
- dynamic
- functional
- concurrent
- Runtime
- compiled to BEAM bytecode and run on Erlang/OTP
- Memory
- automatic memory management on the BEAM, with isolated process heaps managed by the Erlang runtime
- Tooling
- Mix, Hex, Rebar3
Erlang is a dynamically typed, functional language and runtime platform for long-running concurrent systems, centered on lightweight BEAM processes, message passing, OTP supervision, distribution, hot code loading, and telecom-grade fault tolerance.
- active
- dynamic
- functional
- concurrent
- Runtime
- compiled to BEAM bytecode and run on Erlang/OTP
- Memory
- automatic memory management on the BEAM, with lightweight isolated Erlang processes and per-process garbage collection behavior
- Tooling
- Rebar3, Hex
F# is a functional-first .NET language for domain modeling, data-rich applications, backend services, scripting, and tooling where ML-family types, pattern matching, type inference, and C# interoperability fit the platform.
- active
- static
- functional
- object-oriented
- Runtime
- compiled to .NET assemblies for the .NET runtime, with F# Interactive for scripts and exploration, plus community JavaScript targets such as Fable when selected deliberately
- Memory
- managed .NET heap with garbage collection, immutable-by-default values, explicit mutation, disposable resources, and the same native interop escape hatches available through .NET
- Tooling
- NuGet, dotnet CLI, MSBuild
Fortran is a standardized compiled language for numerical computing, scientific simulation, engineering models, dense array work, and long-lived high-performance codebases where modern Fortran and legacy Fortran often coexist.
- active
- static
- numerical
- procedural
- Runtime
- ahead-of-time native compilation through implementation-specific compilers and runtime libraries
- Memory
- automatic storage, allocatable arrays, pointers, explicit allocation and deallocation for dynamic data, and compiler/runtime-managed temporaries
- Tooling
- fpm, CMake, Make
GDScript is Godot's integrated scripting language for gameplay, tools, editor workflows, and Godot-specific content, with Python-like indentation, dynamic typing plus optional static annotations, first-class integration with nodes, scenes, signals, resources, and the Godot editor.
- active
- gradual
- object-oriented
- imperative
- Runtime
- Godot-integrated scripting runtime executed inside Godot projects and editor workflows, with direct access to the engine API, nodes, resources, and scene lifecycle callbacks
- Memory
- managed by Godot's runtime object model, including value types, reference-like arrays and dictionaries, nodes owned by the scene tree, and engine-side resource lifetimes
- Tooling
- Godot Asset Library, project-local addons
Gleam is a statically typed functional language for the Erlang VM and JavaScript runtimes, centered on a small language surface, actor-style BEAM concurrency, Hex packages, integrated tooling, and practical interoperability with Erlang and Elixir.
- active
- static
- functional
- concurrent
- Runtime
- compiled to Erlang source for Erlang/OTP or to JavaScript for JavaScript runtimes
- Memory
- automatic memory management through the target runtime, normally Erlang/OTP garbage collection on the BEAM or JavaScript runtime garbage collection on the JavaScript target
- Tooling
- Gleam build tool, Hex, Gleam package index
Go is a statically typed, compiled language for services, network software, command-line tools, and infrastructure code that benefits from a small language surface, a strong standard toolchain, and built-in concurrency support.
- active
- static
- procedural
- concurrent
- Runtime
- native binaries with Go runtime
- Memory
- garbage collected with explicit pointers and value semantics
- Tooling
- Go modules
Groovy is an Apache-hosted JVM language for scripts, tests, DSLs, Gradle build logic, and Java-adjacent applications, combining dynamic typing with optional static checking and compilation.
- active
- dynamic with optional static type checking and static compilation
- object-oriented
- scripting
- Runtime
- Groovy source compiled to JVM bytecode, with scripts, classes, groovyc, groovysh, Gradle, Maven, and Ant integration
- Memory
- managed by the JVM garbage collector
- Tooling
- Gradle, Maven, Apache Ivy
HCL is HashiCorp Configuration Language, a structured configuration language and Go toolkit used most visibly by Terraform and OpenTofu to describe infrastructure resources, variables, modules, providers, expressions, and desired state.
- active
- schema-defined
- declarative
- configuration
- Runtime
- parsed and evaluated by a host application; Terraform and OpenTofu build dependency graphs, plan changes, call providers, and update state from HCL configuration
- Memory
- not an application memory model; Terraform and OpenTofu persist infrastructure bindings in state while providers manage remote objects through APIs
- Tooling
- Terraform Registry, OpenTofu Registry, terraform init
Haskell is a statically typed, purely functional language centered on purity, lazy evaluation, type inference, algebraic data types, and type classes, with GHC as the dominant practical compiler and toolchain center.
- active
- static
- functional
- declarative
- Runtime
- GHC-compiled native code, bytecode through GHCi, and additional GHC backends or experimental targets depending on release and platform
- Memory
- managed heap with garbage collection in mainstream GHC implementations
- Tooling
- Cabal, Hackage, Stack
Java is a statically typed, class-based language for the JVM, widely used for backend services, enterprise systems, Android-era application code, and long-lived software that benefits from managed runtime tooling and strong compatibility expectations.
- active
- static
- object-oriented
- imperative
- Runtime
- JVM bytecode on Java Virtual Machine implementations
- Memory
- garbage collected heap with managed object references
- Tooling
- Maven, Gradle, Maven Central
JavaScript is a dynamically typed, garbage-collected, prototype-based language standardized as ECMAScript and used across browsers, servers, edge runtimes, tools, and application scripting.
- active
- dynamic
- multi-paradigm
- prototype-based object-oriented
- Runtime
- browser, server, edge, and embedded JavaScript runtimes
- Memory
- garbage collected by host engine
- Tooling
- npm, pnpm, Yarn
Julia is a dynamic, multiple-dispatch language for scientific and numerical computing, designed to let high-level mathematical code compile to efficient specialized machine code while staying interactive and package-driven.
- active
- dynamic
- multiple dispatch
- scientific computing
- Runtime
- LLVM-based just-in-time compilation with package precompilation, sysimages, and optional app or library bundling through PackageCompiler
- Memory
- automatic garbage collection with explicit performance attention to allocation, mutability, arrays, and native interop boundaries
- Tooling
- Pkg, General registry, Manifest.toml
Kotlin is a statically typed JetBrains language for JVM, Android, JavaScript, Wasm, and native targets, best known for Java interoperability, null-safety features, coroutines, and Kotlin Multiplatform shared-code workflows.
- active
- static
- object-oriented
- functional
- Runtime
- JVM bytecode, Android, JavaScript, Wasm, or native binaries through Kotlin target backends
- Memory
- managed by target runtime, including JVM garbage collection and Kotlin/Native tracing garbage collection
- Tooling
- Gradle, Maven, Maven Central
LabVIEW is NI's graphical dataflow programming environment for test, measurement, automation, and control systems, centered on virtual instruments, block diagrams, hardware integration, and optional real-time and FPGA targets.
- active
- static graphical dataflow
- graphical programming
- dataflow
- Runtime
- NI LabVIEW development and run-time environments for host applications, with optional LabVIEW Real-Time targets and LabVIEW FPGA compilation for supported NI hardware
- Memory
- LabVIEW-managed execution, buffers, dataflow values, queues, references, target-specific real-time constraints, and FPGA resources rather than manual heap allocation in ordinary diagrams
- Tooling
- LabVIEW Package Manager, NI Package Manager, VIPM
Lua is a lightweight, dynamically typed scripting language designed to be embedded in host applications, with a small C implementation, a register-based virtual machine, tables as the central data structure, metatables for extensibility, and a long role in game, plugin, configuration, and application scripting.
- active
- dynamic
- procedural
- object-oriented through tables and metatables
- Runtime
- register-based bytecode virtual machine implemented as an embeddable ISO C library, with standalone interpreter and alternate implementations
- Memory
- automatic memory management with incremental and generational garbage collection
- Tooling
- LuaRocks, rockspec, luarocks
MATLAB is a proprietary matrix-first programming and numeric computing environment for engineers, scientists, and researchers, strongest where interactive analysis, numerical algorithms, visualization, toolboxes, and Simulink-based engineering workflows matter more than open runtime distribution.
- active
- dynamic
- numerical
- array-oriented
- Runtime
- proprietary MATLAB execution environment for interactive, script, function, app, and toolbox workflows; deployed artifacts use MATLAB Runtime or generated C/C++ where supported
- Memory
- automatic memory management around multidimensional arrays, objects, and workspace values, with performance shaped by allocation, array size, vectorization, and toolbox/native-library boundaries
- Tooling
- Add-On Explorer, MATLAB Central File Exchange, Toolboxes
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
Mojo is a Python-syntax, MLIR-based systems and accelerator programming language from Modular, currently centered on CPU/GPU kernels, Python interoperability, MAX integration, ownership-based value semantics, and a still-maturing package and stability story.
- active
- static with Python interoperability
- multi-paradigm
- systems
- Runtime
- compiled with AOT and JIT workflows through the Mojo toolchain, with optional CPython runtime use for Python interoperability and MAX integration for AI graph and kernel workloads
- Memory
- ownership-based value semantics without a garbage collector or reference counter for Mojo values, with explicit unsafe pointer and manual lifecycle tools for low-level code
- Tooling
- uv, pixi, conda
Nim is a statically typed compiled language with Python-like indentation, native C/C++/Objective-C and JavaScript backends, macros, configurable memory management, and a systems-scripting feel for native tools, libraries, and C-adjacent applications.
- active
- static
- systems
- imperative
- Runtime
- ahead-of-time compilation through generated C, C++, Objective-C, or JavaScript, normally producing native binaries through a platform C toolchain and no required virtual machine
- Memory
- deterministic and configurable memory management, with ORC as the default in Nim 2.x plus ARC, refc, mark-and-sweep, Boehm, Go GC, and manual/no-management modes for specialized targets
- Tooling
- Nimble, Atlas, choosenim
OCaml is a strict ML-family language for functional-first native and bytecode programs, centered on type inference, algebraic data types, pattern matching, modules, functors, managed memory, opam, and Dune.
- active
- static
- functional
- imperative
- Runtime
- bytecode through ocamlc and ocamlrun, native code through ocamlopt, interactive toplevels, and OCaml 5 domains for shared-memory parallelism
- Memory
- managed heap with garbage collection, immutable-by-default values, explicit mutable references and fields, and multicore runtime support in OCaml 5
- Tooling
- opam, Dune, OCaml Platform
Objective-C is a compiled C-family language with Smalltalk-style message sending and a dynamic runtime, still important for Apple-platform legacy code, Cocoa and Cocoa Touch frameworks, Objective-C++ bridges, and incremental migration to Swift.
- active
- static and dynamic
- object-oriented
- imperative
- Runtime
- native code compiled by Clang/LLVM plus the Objective-C runtime for dynamic message dispatch, class metadata, selectors, categories, protocols, and reflection
- Memory
- Automatic Reference Counting for Objective-C objects and blocks in modern builds, with manual retain/release history, autorelease pools, weak references, and no cycle collector
- Tooling
- Xcode, CocoaPods, Carthage
Odin is a young, statically typed systems language by Ginger Bill / Bill Hall for high-performance, data-oriented native software, with manual memory management, explicit allocator support, built-in array programming, strong C interop, and no official package manager.
- active
- static
- systems
- procedural
- Runtime
- ahead-of-time native compilation through the Odin compiler, with support for C ABI interop and small runtime assumptions
- Memory
- manual memory management with allocator-aware built-ins, explicit cleanup, context-provided allocators, and no required garbage collector
- Tooling
- manual vendoring, core library collection, vendor library collection
PHP is a dynamically typed, garbage-collected scripting language centered on server-side web applications, content management systems, request/response backends, and Composer-based package ecosystems.
- active
- dynamic
- imperative
- procedural
- Runtime
- Zend Engine interpreter for web server SAPIs, PHP-FPM, CLI scripts, workers, and embedded runtimes
- Memory
- automatic memory management through reference counting and cyclic garbage collection
- Tooling
- Composer, Packagist, PECL
PL/SQL is Oracle's procedural extension to SQL for stored database logic, packages, procedures, functions, triggers, exceptions, data-local business rules, and Oracle Database applications that deliberately keep work close to relational data.
- active
- static with database-bound dynamic features
- procedural
- database
- Runtime
- PL/SQL units are compiled by Oracle Database, stored in the database when persistent, and executed by the Oracle Database PL/SQL engine alongside SQL execution
- Memory
- Oracle Database-managed execution memory, package state, cursors, collections, shared pool objects, transactions, and database storage rather than manual heap allocation
- Tooling
- Oracle Database schemas, SQL scripts, SQLcl
Perl is a dynamically typed, general-purpose scripting language created for practical text processing and Unix automation, with deep regular-expression support, CPAN as its package ecosystem, strong backward-compatibility culture, and a long role in system administration, web history, glue code, and legacy maintenance.
- active
- dynamic
- procedural
- scripting
- Runtime
- interpreted by the Perl 5 interpreter after compilation to an internal syntax tree and opcode execution model
- Memory
- automatic memory management through the Perl interpreter, primarily reference-count driven with cycle risks for self-referential structures
- Tooling
- CPAN, cpan, cpanm
PowerShell is Microsoft's cross-platform command shell and scripting language for task automation, built around .NET objects, modules, remoting, and administrative tooling.
- active
- dynamic
- command language
- imperative
- Runtime
- interpreted and executed by the PowerShell engine on .NET; Windows PowerShell 5.1 remains Windows-bound while modern PowerShell 7 runs cross-platform
- Memory
- managed by the .NET runtime; scripts normally coordinate objects, commands, files, services, and remote sessions rather than manual allocation
- Tooling
- PowerShell Gallery, PowerShellGet, PSResourceGet
Prolog is a logic programming language for expressing facts, rules, relations, and queries, with unification, backtracking, recursion, and constraint logic programming as its central practical tools.
- active
- dynamic
- logic
- declarative
- Runtime
- interactive and compiled Prolog systems, commonly using a WAM-style abstract machine or implementation-specific bytecode/native compilation, with SWI-Prolog as a common open source environment
- Memory
- implementation-managed stacks, heaps, trails, and garbage collection for terms, choice points, variables, and compiled predicates; ordinary Prolog code rarely performs manual memory management
- Tooling
- SWI-Prolog packs, implementation libraries, OS packages
Python is a dynamically typed, general-purpose language centered on readability, a large standard library, and a broad package ecosystem for scripting, automation, web services, data work, scientific computing, and machine learning.
- active
- dynamic
- multi-paradigm
- procedural
- Runtime
- interpreted bytecode on CPython and other Python implementations
- Memory
- garbage collected; CPython primarily uses reference counting plus cyclic garbage collection
- Tooling
- pip, PyPI, venv
R is a dynamically typed language and environment for statistical computing, graphics, data analysis, statistical modeling, and research workflows, with CRAN, data frames, packages, and reporting tools at the center of everyday use.
- active
- dynamic
- statistical computing
- array-oriented
- Runtime
- interpreted statistical computing environment with native extension interfaces
- Memory
- automatic garbage collection with R-managed objects and copy-on-modify user semantics
- Tooling
- CRAN, install.packages, renv
Ruby is a dynamically typed, garbage-collected language centered on expressive object-oriented programming, productive scripting, RubyGems and Bundler package workflows, and web application development shaped heavily by Ruby on Rails.
- active
- dynamic
- object-oriented
- imperative
- Runtime
- interpreted bytecode on CRuby/MRI and other Ruby implementations
- Memory
- automatic garbage collection
- Tooling
- RubyGems, Bundler
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
SAS is a proprietary statistical programming language and analytics platform centered on DATA step data preparation, PROC-based analysis, SAS data sets, macro-generated programs, and long-lived enterprise and clinical reporting workflows.
- active
- dynamic with data-set metadata
- statistical computing
- data analysis
- Runtime
- proprietary SAS execution environments for DATA steps, PROC steps, macro expansion, SAS 9 sessions, SAS Studio, and SAS Viya/CAS-backed analytics
- Memory
- SAS runtime-managed data sets, work libraries, procedure memory, CAS tables where used, and external database engines rather than manual heap allocation
- Tooling
- SAS procedures, SAS macros, SAS Studio
SQL is a standardized relational database language and dialect family for defining schemas, querying tables, changing data, expressing transactions, and moving work close to database engines.
- active
- static
- declarative
- relational
- Runtime
- interpreted and optimized by relational database engines and dialect-specific execution layers
- Memory
- database-managed storage, buffers, indexes, transactions, and execution memory
- Tooling
- Varies by ecosystem
Scala is a statically typed, multi-paradigm language whose main production home is the JVM, combining object-oriented and functional programming with a rich type system, Java interoperability, and ecosystems for backend services, distributed systems, and Spark data work.
- active
- static
- object-oriented
- functional
- Runtime
- JVM bytecode by default, with Scala.js for JavaScript and Scala Native for native binaries
- Memory
- managed by target runtime, primarily JVM garbage collection
- Tooling
- sbt, Scala CLI, Coursier
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
Scratch is a free, block-based visual programming language and creative coding community for children, classrooms, clubs, and first programming experiences built around interactive stories, games, animations, sprites, media, and sharing.
- active
- dynamic
- visual
- block-based
- Runtime
- Scratch projects run in the Scratch web editor/player or Scratch desktop environment through the Scratch 3.0 JavaScript-based editor, VM, blocks, renderer, storage, and media tooling
- Memory
- managed by the Scratch runtime and project model; learners work with variables, lists, sprites, clones, costumes, sounds, and stage state rather than explicit allocation
- Tooling
- Varies by ecosystem
Solidity is a statically typed, contract-oriented language for Ethereum and EVM-compatible smart contracts, where source code compiles to EVM bytecode and production work is shaped by gas costs, public execution, irreversible deployment risk, testing, auditing, and contract verification.
- active
- static
- contract-oriented
- object-oriented
- Runtime
- Solidity source compiles to EVM bytecode executed by Ethereum and EVM-compatible chains
- Memory
- EVM storage, transient storage, memory, calldata, and stack data areas; persistent contract state is explicit and gas-sensitive
- Tooling
- solc, Remix, Hardhat
Swift is a statically typed, compiled Apple-origin language for iOS, macOS, watchOS, tvOS, visionOS, server-side Linux services, command-line tools, packages, and emerging cross-platform targets, best known for optionals, value types, ARC, Swift concurrency, and Objective-C/C/C++ interoperability.
- active
- static
- object-oriented
- protocol-oriented
- Runtime
- native code through Swift toolchains, LLVM, platform SDKs, the Swift runtime, and target-specific standard/core libraries
- Memory
- automatic reference counting for class instances, value semantics for structs and enums, exclusivity checks, and explicit unsafe pointer escape hatches
- Tooling
- Swift Package Manager, Xcode, CocoaPods
Transact-SQL is Microsoft's SQL Server and Azure SQL dialect for relational queries, schema work, procedural database logic, stored procedures, functions, triggers, temporary tables, transactions, and operational database programming.
- active
- static with database-bound dynamic features
- procedural
- database
- Runtime
- Transact-SQL batches and modules are parsed, optimized, compiled, cached, and executed by the Microsoft SQL Database Engine across SQL Server, Azure SQL, and related Microsoft data services
- Memory
- SQL Server Database Engine-managed storage, buffers, tempdb, plan cache, locks, row versions, transactions, and execution memory rather than manual heap allocation
- Tooling
- SQL Server schemas, SQL scripts, SQL Server Management Studio
TypeScript is a typed superset of JavaScript that adds static analysis and type annotations while compiling to JavaScript for existing runtimes.
- active
- static
- multi-paradigm
- object-oriented
- Runtime
- JavaScript runtime
- Memory
- host runtime managed
- Tooling
- npm, pnpm, Yarn
Visual Basic for Applications is Microsoft's Office-hosted macro and automation language for Excel, Access, Word, Outlook, PowerPoint, and COM-era desktop workflows.
- active
- static and dynamic
- procedural
- imperative
- Runtime
- interpreted/compiled macro code hosted inside desktop Office applications and their object models, with Windows COM automation as the strongest integration path
- Memory
- managed by the Office host, VBA runtime, and COM reference-counted objects; production code still needs explicit cleanup for files, external processes, database connections, and long-lived object references
- Tooling
- Office object libraries, COM references, Office templates and add-ins
VHDL is an IEEE-standardized hardware description and verification language for modeling, simulating, verifying, and synthesizing digital logic for FPGA, ASIC, and high-integrity hardware designs.
- active
- static hardware-oriented
- hardware description
- register-transfer level
- Runtime
- analyzed and elaborated by VHDL simulators for verification, or accepted by synthesis tools that translate a supported synthesizable subset into FPGA or ASIC netlists
- Memory
- hardware state, signals, registers, variables, memories, and simulation objects rather than an application heap or garbage-collected runtime
- Tooling
- IEEE 1076, IEEE std_logic_1164, IEEE numeric_std
Verilog and SystemVerilog are hardware description and verification languages for modeling, simulating, verifying, and synthesizing digital logic for FPGA, ASIC, and SoC designs.
- active
- static hardware-oriented
- hardware description
- register-transfer level
- Runtime
- interpreted or compiled by HDL simulators for verification, or accepted by synthesis tools that translate a synthesizable subset into FPGA or ASIC netlists
- Memory
- hardware state, signals, registers, wires, memories, and simulation objects rather than an application heap or garbage-collected runtime
- Tooling
- IEEE 1800, UVM, Verilator
Visual Basic is Microsoft's approachable BASIC-family language line, now centered on stable .NET application and library maintenance, with classic VB and VBA still important around Windows desktop, COM, and Office automation.
- active
- static and dynamic
- object-oriented
- imperative
- Runtime
- compiled to .NET assemblies for modern Visual Basic; classic VB6 compiles to 32-bit Windows applications that use the VB6 runtime; VBA runs inside Office host applications
- Memory
- managed by the .NET garbage collector for modern Visual Basic; classic VB and VBA rely on COM reference counting, runtime objects, forms, controls, and host application lifetimes
- Tooling
- NuGet, dotnet CLI, MSBuild
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
