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