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
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
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
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
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
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
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
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
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
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
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
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
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
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
