References

Standard Model (SM) describes a large group of languages with Algol-like syntax and the following traits:

There may or may not be a statement terminator/separator.

C model adds to SM

Winged comments were introduced in C99 from C++ and were not present in older C.

ABC is an educational programming language developed at CWI in the 1980s as a teaching language emphasizing readability, structured programming, and interactive use. It was designed to replace BASIC for beginners while avoiding many of BASIC’s irregularities. ABC’s design later influenced the development of Python.

ABNF (Augmented Backus-Naur Form) is a domain-specific grammar notation used in many protocol specifications. This is a Grammar-oriented notation, not a general-purpose programming language.

ActionScript is a C/JavaScript-family proprietary programming language developed for Adobe’s Flash platform (later AIR). It exists in multiple major versions; ActionScript 3 is an ECMAScript-derived language with a class-based object model and a bytecode VM (AVM2).

Agda is a dependently typed functional programming language designed for writing programs together with machine-checked proofs. It is used for theorem proving, type-driven development, and research in programming-language theory. Agda code resembles the ML/Haskell family in its expression syntax, but its type system is substantially more expressive.

The various forms of literate Agda are not yet supported.

SM plus a tick operator; tick always follows and precedes an identifier with no whitespace intervening.

Alda is a programming language for music composition that allows musical scores to be written as text. Alda programs describe instruments, notes, rhythms, and tempo using a notation designed to resemble traditional music notation. The Alda runtime interprets this to produce MIDI events or audio output, allowing compositions to be generated and played programmatically.

This Alex is a parser generator for Haskell.

This Alex is a language that "provides a modular approach for defining external visitor-like semantics on top of ecore based abstract syntax.", whatever that might mean.

ALGOL 60 (Algorithmic Language 1960) was one of the earliest block-structured programming languages and had a major influence on later languages such as Pascal, C, and many others. It introduced lexical scoping, nested procedure definitions, and structured control flow to programming-language design. The language was widely used in academic computing in the 1960s and early 1970s.

ALGOL 68 (Algorithmic Language 1968) is a successor to ALGOL 60 designed by the IFIP Working Group 2.1. It introduced a much richer type system, orthogonal language design, and structured control constructs. Although its specification was considered complex at the time, ALGOL 68 influenced later languages through its ideas about strong typing, structured data, and uniform expression syntax.

ALGOL W is a programming language developed in the mid-1960s by Niklaus Wirth and Tony Hoare as a simplified and practical successor to ALGOL 60. It introduced several ideas that later influenced Pascal and other structured programming languages. ALGOL W programs use block structure with "begin" and "end", typed variables, procedures, and control constructs such as "if", "while", and "for". The language also introduced record types and reference variables, features that later became common in many programming languages.

Alice ML is a functional programming language derived from Standard ML that extends the ML language family with features for concurrency, distribution, and laziness. It was developed as a research platform for exploring scalable distributed systems using strongly typed functional programming.

Alloy is a declarative modeling language for relational structures, typically analyzed with the Alloy Analyzer.

AnsProlog, also known as Answer Set Programming (ASP), is a declarative logic programming language used to represent knowledge and solve combinatorial search problems. Programs consist of logical rules whose solutions are computed as answer sets by specialized ASP solvers.

Ant refers to build scripts used by Apache Ant, a Java-based build automation tool. Ant build files describe how software should be compiled, packaged, tested, and deployed using a declarative XML-based configuration format.

ANTLR (ANother Tool for Language Recognition) is a parser generator used to build compilers, interpreters, and language-processing tools. ANTLR grammars describe the lexical tokens and syntactic structure of languages using a declarative grammar notation that is compiled into parsers for multiple programming languages.

APL (A Programming Language) is an array-oriented programming language developed by Kenneth Iverson. It is known for its concise notation and use of a specialized character set to express operations on arrays and matrices. APL programs typically consist of compact expressions that apply primitive operators to whole arrays.

Arc is a Lisp dialect designed by Paul Graham and Robert Morris as a lightweight language for rapid development and exploratory programming. It runs on top of a Racket implementation and keeps the traditional Lisp model of code-as-data while attempting to simplify and streamline common Lisp constructs.

Arduino C is a simplified dialect of C used in the Arduino microcontroller toolchain. Programs (called "sketches") are compiled with a modified C compiler and linked against the Arduino runtime library, which provides simplified interfaces for I/O, timing, and hardware peripherals. The language itself is essentially C with some preprocessing and convenience functions supplied by the build system.

Arturo is a modern, open-source programming language focused on simplicity, expressiveness, and rapid development. Inspired by languages such as Rebol and Red, it emphasizes a compact syntax and powerful built-in functionality for tasks including text processing, data manipulation, networking, and scripting. Arturo aims to provide a practical, batteries-included environment suitable for automation, prototyping, and general-purpose programming.

loccount reports "asm" for anything it identifies as assembler source code by file extension, because identifying instruction sets reliably is beyond it.

AsciiDoc is a lightweight plain-text markup language designed for writing technical documentation, books, and articles. It provides a rich set of structural and formatting constructs while remaining readable as ordinary text. AsciiDoc documents are commonly processed into HTML, PDF, or other publishing formats by tools such as Asciidoctor.

ASN.1 (Abstract Syntax Notation One) is a formal interface-description language used to define structured data for protocols and file formats.

ASP.NET is a server-side web application framework originally developed by Microsoft for building dynamic web pages and web services on the .NET platform. ASP.NET pages combine HTML markup with embedded code written in languages such as C# or Visual Basic, along with special directives and server controls interpreted by the ASP.NET runtime.

AspectJ is an aspect-oriented programming extension to the Java language. It introduces constructs for modularizing cross-cutting concerns such as logging, error handling, and security that would otherwise be scattered throughout a code base.

Asymptote is a vector graphics language designed for producing high-quality mathematical and technical illustrations. It provides a C-like programming syntax combined with geometric primitives and drawing operations for creating precise diagrams.

ATS is a statically typed programming language that unifies implementation with formal specification. It is equipped with a highly expressive type system rooted in the framework Applied Type System, which gives the language its name. In particular, both dependent types and linear types are available in ATS.

Automake is a GNU build-system DSL used to generate portable "Makefile.in" templates that are later configured into Makefiles.

Autoconf refers to the GNU build-system toolchain built around Autoconf, Automake, and related utilities. Autoconf input files are DSL-like configuration and template files used to generate portable build scripts (notably the "configure" script and "Makefile.in" templates) that adapt software builds to different Unix-like systems.

This tag identifies all autotools source and template files other than Automake source files. Files may contain shell-like syntax or C-preprocessor fragments, depending on the file type. Reference:: https://www.gnu.org/software/automake/manual/

AWK is a pattern-scanning and text-processing language originally developed at Bell Labs by Alfred Aho, Peter Weinberger, and Brian Kernighan. It is widely used for processing structured text files, especially line-oriented data such as logs or tabular text. AWK programs consist of pattern/action pairs applied to successive input records.

B was an early systems programming language developed at Bell Labs around 1969 by Ken Thompson and Dennis Ritchie. It was designed as a simplified derivative of BCPL and served as the immediate predecessor to C.

BaCon (BASIC Converter) is a programming language and translator that converts a dialect of BASIC into C code, which is then compiled to produce native executables. It was designed to provide the simplicity of BASIC while generating efficient compiled programs through the C toolchain.

Ballerina is an open-source programming language designed for networked and distributed applications. Developed by WSO2, it integrates language features with network concepts such as services, endpoints, and structured data exchange (JSON, XML, HTTP) as first-class constructs. Its syntax is broadly C/Java-like but adds language-level support for concurrency, type-safe network protocols, and service-oriented programming.

BASIC (Beginner’s All-purpose Symbolic Instruction Code) is a family of programming languages originally designed in the 1960s for teaching programming to beginners. Early dialects used line numbers and interactive execution, while later variants added structured programming constructs.

DOS batchfiles are command-interpreter scripts used by MS-DOS and the Windows command shell ('cmd.exe') to automate sequences of commands. They are typically stored in files with extensions such as '.bat' or '.cmd'. Batch programs consist of command lines interpreted by the shell, along with simple control-flow constructs such as conditionals, loops, and labels.

Bazel is a build-system DSL used to describe software build targets, dependencies, and rules in a reproducible way. It was developed at Google and later released as open source. Bazel build files ("BUILD", ".bazel", and ".bzl") use a Python-like syntax derived from the Starlark language, but are restricted to deterministic, side-effect-free constructs suitable for build descriptions.

BCPL (Basic Combined Programming Language) is a minimalist, typeless systems programming language created in the 1960s by Martin Richards, notable as a direct ancestor of B and therefore C; it was designed to be portable and easy to implement via a small compiler and runtime model, using block structure and simple syntax (including //-style comments in many dialects) while leaving machine details fairly exposed, which made it practical for early operating systems, compilers, and tooling on diverse hardware even though it has largely been superseded by C-family languages today.

Beeflang (often written just "Beef") is a proprietary, statically typed systems programming language designed for performance-critical applications such as game engines and real-time software. It combines C-family syntax with modern language features such as generics, compile-time metaprogramming, and integrated tooling for debugging and memory management.

Berry is a lightweight embeddable scripting language designed for resource-constrained systems such as microcontrollers and IoT devices. It is used in firmware environments such as Tasmota to provide a flexible scripting layer for device control and automation.

BibTeX is a bibliographic database format used by LaTeX for managing references. BibTeX files store structured records describing books, articles, and other publications that can be cited in documents.

Bicep is a domain-specific language (DSL) developed by Microsoft for deploying and managing Azure cloud infrastructure. It provides a concise, declarative syntax for defining Azure resources and configurations, compiling directly to Azure Resource Manager (ARM) templates. Bicep is designed to simplify infrastructure-as-code workflows by improving readability, modularity, and tooling support compared to raw ARM JSON templates.

BitBake is a task-execution and build-description DSL used by the Yocto Project and OpenEmbedded build systems. BitBake files describe software recipes, dependencies, and build steps for constructing complete embedded Linux systems. The language combines a declarative variable syntax with embedded Python fragments for more complex build logic.

Blade is the templating language used by the Laravel PHP web framework. It is designed to simplify the construction of HTML views while allowing embedded PHP expressions and control structures.

BLISS (Basic Language for Implementation of System Software) is a systems programming language developed at Carnegie Mellon University in the early 1970s and later widely used at Digital Equipment Corporation for operating systems and compilers. It is a typeless language emphasizing efficient low-level programming and explicit control of data representation.

Blueprint is a declarative user-interface description language used with the GTK toolkit. It provides a concise syntax for defining GTK widget hierarchies and properties and is compiled into GtkBuilder XML files used by GTK applications.

All thee languages use the straight C model. Yacc and Lex have %% sections with different syntax. Java string and character literals may contain Unicode.

C and C++ header files.

CppModule refers to C source files that define module interface or module implementation units using the C20 modules system. C++ modules provide a modern mechanism for organizing and importing program interfaces, replacing many traditional uses of header files and the preprocessor.

C# is a general-purpose programming language developed by Microsoft as part of the .NET platform. It combines object-oriented programming with strong static typing, automatic memory management, and a large standard library. C# is widely used for building desktop applications, web services, enterprise software, and games, and supports multiple programming styles including object-oriented, functional, and asynchronous programming.

C3 is a modern systems programming language designed as an evolution of C, aiming to improve safety, ergonomics, and compile-time features while retaining the simplicity and performance characteristics of C. It adds conveniences such as modules, stronger type checking, compile-time evaluation, and improved error handling without adopting a radically different programming model. C3 is intended for systems, embedded, and performance-critical software where low-level control and predictable behavior are important.

Cabal files describe Haskell packages (metadata, dependencies, and build layout) for the Cabal build system.

Cadence is a resource-oriented smart-contract programming language used on the Flow blockchain. It provides strong static typing and a unique resource model designed to ensure safe handling of digital assets.

Cairo is a programming language designed for writing provable programs that can be verified using zero-knowledge proofs. Originally developed by StarkWare, it is used to create programs whose execution can be efficiently proven and verified on blockchain systems. Cairo is particularly associated with the StarkNet ecosystem, where it is used to write smart contracts and other verifiable computations.

Cake build scripts are written for Cake (C# Make), a cross-platform build automation system for the .NET ecosystem. Cake scripts use a C#-based domain-specific language to define build tasks, dependencies, and workflows for compiling, testing, packaging, and deploying software. Because the language is built on top of C# and the .NET runtime, Cake scripts can use existing .NET libraries and tooling while providing higher-level constructs tailored to build automation.

Cangjie is a statically typed general-purpose programming language developed by Huawei. It is designed for application development across multiple platforms and combines imperative, functional, and object-oriented features in a modern compiled language.

Capnp refers to schema definition files used by the Cap’n Proto serialization and remote procedure call system. Cap’n Proto schemas describe structured data types and service interfaces that can be compiled into efficient code for multiple programming languages.

Carbon is an experimental statically typed programming language designed as a potential successor to C. It aims to provide modern language features, improved safety, and better tooling while maintaining interoperability with existing C codebases.

Carp is a statically typed functional programming language designed for efficient compilation to C. It combines a Lisp-like syntax with features intended for systems programming, including predictable memory management and ahead-of-time compilation.

CFDG (Context Free Design Grammar) is a domain-specific language used by the Context Free program to generate algorithmic graphics. A CFDG program defines rules that recursively expand shapes into more shapes, producing complex images through repeated application of grammar rules. The language describes shapes, transformations, and probabilities using a rule-based syntax similar to formal grammars. Rendering the grammar produces fractal-like or procedural artwork.

CFML (ColdFusion Markup Language) is a server-side web DSL with both tag-based and script-style forms, commonly used in ".cfm" and ".cfc" files. It was originally developed for Adobe’s ColdFusion product, but multiple open-source implementations now exist.

CFScript is the scripting syntax of the ColdFusion programming language. It provides a C- and Java-style expression and block syntax as an alternative to the original tag-based ColdFusion Markup Language (CFML). CFScript programs use statements, braces, and semicolons rather than "<cf…​>" tags, but execute in the same ColdFusion runtime environment and provide access to the same built-in functions and libraries.

CFScript code may appear inside "<cfscript>" blocks in traditional CFML templates or in standalone script files. These files commonly use the extension ".cfs", though CFScript syntax can also appear in ".cfm" or ".cfc" files.

Chapel is a parallel programming language designed for high-performance computing and large-scale systems. It was developed by Cray (now HPE) as part of the DARPA High Productivity Computing Systems program. Chapel combines a modern imperative syntax with built-in constructs for data parallelism, task parallelism, and distributed memory execution.

Chisel (Constructing Hardware In a Scala Embedded Language) is a hardware-construction language used to design digital circuits. It is embedded in Scala and allows hardware designs to be written as parameterized programs that generate Verilog. Chisel is widely used in academic and industrial processor design projects.

Because Chisel source files are Scala programs, the lexical syntax is largely that of Scala.

ChucK is a strongly timed, concurrent programming language designed for real-time sound synthesis and music creation. Developed at Princeton University, it provides precise control over timing and audio processing through a model known as "strongly-timed programming." ChucK is widely used for experimental music, live coding performances, and audio research, allowing programmers to interactively modify running programs while sound is being generated.

CIL (Common Intermediate Language) is a low-level, stack-based intermediate language used by the .NET runtime. It serves as the target output of .NET compilers such as C#, F#, and Visual Basic, representing programs in a platform-neutral form that can be executed by the Common Language Runtime. At runtime, CIL code is typically compiled to native machine code by a just-in-time compiler.

Circom is a domain-specific language for defining arithmetic circuits used in zero-knowledge proof systems, particularly zk-SNARK workflows. Programs describe constraint systems rather than conventional control flow and are typically compiled into R1CS or related proving formats.

Civet is a programming language that compiles to JavaScript. It introduces a simplified syntax intended to improve readability while remaining closely compatible with modern JavaScript semantics. Civet source code is compiled to standard JavaScript before execution.

Clarity is a smart-contract programming language used on the Stacks blockchain. The language is designed to be predictable and statically analyzable so that contract behavior and execution costs can be determined before deployment. Contracts are stored and executed directly from their source code.

Clean is a statically typed, purely functional programming language related to Haskell and other lazy functional languages but introduces a distinctive type system feature called uniqueness types, which allow destructive updates while preserving referential transparency.

Clojure is a modern Lisp dialect that runs primarily on the Java Virtual Machine and emphasizes functional programming, immutable data structures, and concurrency. It retains the traditional Lisp homoiconic syntax while integrating closely with host platforms such as the JVM, JavaScript (via ClojureScript), and .NET.

ClojureC refers to portable Clojure source written in .cljc files, intended to be read by multiple Clojure platforms (most commonly JVM Clojure and ClojureScript). The distinguishing feature of .cljc is reader conditionals (#? / #?@) for platform-specific forms. clojure.org

ClojureScript is a dialect of Clojure that compiles to JavaScript, allowing Clojure programs to run in web browsers and other JavaScript environments. It preserves the Lisp syntax and functional programming model of Clojure while interoperating with the JavaScript ecosystem and runtime.

CLU is a statically typed programming language developed at MIT in the 1970s for research into data abstraction and modular programming. It introduced influential concepts such as abstract data types, parameterized modules, and iterators, many of which later appeared in languages such as Ada, C++, and Java.

CMake is a cross-platform build-system language and tool used to generate native build files for a variety of build environments such as Make, Ninja, and Visual Studio. CMake source files (typically "CMakeLists.txt" or ".cmake" modules) consist of command-style directives with arguments and variables used to describe build rules, dependencies, and configuration logic.

CML (Concurrent ML) is an extension of Standard ML that adds first-class concurrency primitives based on synchronous message passing. It was developed at Cornell University and influenced later concurrent programming models through its use of typed channels and composable communication events.

COBOL (Common Business-Oriented Language) is a programming language developed in the late 1950s for business data processing. It is known for its verbose, English-like syntax and strong emphasis on record structures and decimal arithmetic. COBOL has been widely used in enterprise systems, especially for financial, accounting, and transaction-processing applications.

Cobra is a statically typed, object-oriented programming language designed to combine scripting-style productivity with strong typing, contracts, and integration with the .NET ecosystem. It borrows ideas from Python, C#, and Eiffel, including indentation-sensitive syntax and design-by-contract features such as preconditions and invariants.

CoffeeScript is a small, expressive language that compiles to JavaScript. It was created to provide a cleaner, more concise syntax while preserving full interoperability with JavaScript. It implemented class syntax before ES6 standardized it.

Cogent is a systems language with an affine type discipline, designed for verification-oriented low-level software.

COMAL is a structured programming language developed in the 1970s as an educational alternative to BASIC. Its name derives from "COMmon Algorithmic Language". COMAL combines the simple syntax and interactive environment of BASIC with structured programming constructs inspired by languages such as Pascal.

Constraint Grammar is a rule-based language used for morphological and syntactic disambiguation in natural-language processing. Programs define context-sensitive rules that remove or select possible analyses for words produced by a morphological analyzer.

CORC (the CORnell Computing language) was a simple computer language developed at Cornell University in 1962 to serve lay users, namely for students to use to solve math problems. It was superseded by CUPL; both languages are extinct, but a retrocompiler exists.

Crystal is a statically typed, compiled programming language with syntax inspired by Ruby. It aims to combine Ruby-like expressiveness with the performance of a compiled language.

csh (the C shell) is a Unix command interpreter originally written by Bill Joy in the late 1970s. It introduced a C-like expression syntax for control structures and became widely used as an interactive shell on BSD systems. While historically influential, it has largely been superseded by more modern shells for scripting.

CSON (CoffeeScript Object Notation) is a data-serialization format derived from the syntax of CoffeeScript. It was created to provide a more human-readable alternative to JSON while preserving a similar data model. CSON represents structured data using key–value pairs, arrays, and nested objects. Unlike JSON, it allows unquoted object keys, optional commas, and indentation-based structure. Strings may be written using single or double quotes and follow CoffeeScript-style escape rules.

CSS (Cascading Style Sheets) is a declarative stylesheet language used to describe the presentation of structured documents such as HTML and XML. It specifies visual layout, colors, fonts, spacing, and other rendering properties for web documents. CSS rules associate style properties with selectors that match elements in a document tree.

CSV (Comma-Separated Values) is a plain-text tabular data format described by RFC 4180. Each record appears on a separate line, and fields within a record are separated by commas. Fields may optionally be enclosed in double quotes. If a field contains a comma, double quote, or line break, it must be quoted. Double quotes inside quoted fields are escaped by doubling them.

RFC 4180 does not define a comment syntax. Lines are interpreted only as records, and all characters outside the quoting rules are treated as field data.

CUDA (Compute Unified Device Architecture) is NVIDIA’s proprietary programming model and language extension for writing parallel programs that run on GPUs. CUDA source files are largely C or C++ with additional keywords, attributes, and runtime APIs used to launch and manage massively parallel kernels executing on the device.

CUE is a data-constraint and configuration language designed for defining, validating, and generating structured data such as JSON or YAML. It combines a declarative data notation with a type and constraint system, allowing schemas and values to be expressed in the same language and unified during evaluation.

Cython is a programming language that extends Python with optional static typing and direct interoperability with C and C++ code. It is commonly used to improve the performance of Python programs by compiling Python-like code into C extensions, enabling faster execution and efficient access to native libraries. Cython maintains a syntax largely compatible with Python while allowing developers to add type annotations and low-level constructs for performance-critical sections of code.

CUPL (Cornell University Programming Language) was a simple computer language developed at Cornell University in 1966 to serve lay users, namely for students to use to solve math problems. It superseded CORC from 1962; both languages are extinct, but a retrocompiler exists.

D is a statically typed systems programming language designed as a successor to C and C++. It combines C-like syntax and native performance with modern language features such as modules, contracts, garbage collection, and compile-time metaprogramming. D aims to retain the efficiency of low-level languages while improving safety and developer productivity.

D2 is a declarative programming language for creating diagrams from text. It allows users to describe diagrams such as architecture diagrams, flowcharts, and sequence diagrams using a concise, readable syntax. D2 is designed to make diagram creation reproducible, version-controllable, and easy to integrate into documentation and development workflows.

Dafny is a programming language designed for formal verification of software. Programs include specifications such as preconditions, postconditions, and invariants that are checked automatically by a theorem prover to ensure program correctness.

DAML is a smart contract programming language designed for building distributed applications with strong guarantees about data integrity and transaction correctness. Originally developed by Digital Asset, it uses a declarative model to describe business workflows and the rights of parties participating in them. DAML applications can run on various distributed ledger platforms as well as conventional systems, allowing developers to define complex contractual relationships and automate their execution.

Dart is a class-based programming language developed by Google for building client and server applications. It is most widely used with the Flutter framework for cross-platform user-interface development. Dart programs may be executed by a virtual machine during development or compiled ahead of time to native code or JavaScript for deployment.

DebianControl refers to control files used by the Debian packaging system to describe package metadata. These files define information such as the package name, version, dependencies, maintainer, and description, and are interpreted by Debian package management tools when building or installing packages.

Delphi is an object-oriented programming language derived from Pascal and used primarily for developing native desktop applications. It extends Pascal with classes, properties, exceptions, and a rich component framework for rapid application development. The language is commonly used with the Delphi IDE and RAD Studio toolchain.

Der is a statically typed systems programming language designed as a modern alternative to C. It emphasizes explicit control, predictable performance, and simple language semantics while avoiding some of the complexity of larger systems languages. Der provides features such as strong typing, manual memory management, and a straightforward syntax intended for low-level and performance-critical software.

DesktopFile refers to Linux desktop entry files used by desktop environments such as GNOME and KDE to describe how applications should be launched and presented in menus and other user-interface contexts. The format is standardized by freedesktop.org and is commonly used for application launchers, MIME associations, and desktop actions.

DeviceTree source files describe the hardware layout of a system in a structured data format used by the Linux kernel and other embedded operating systems. They specify devices, buses, memory regions, and configuration parameters in a hierarchical tree that is compiled into a binary device tree blob (DTB) consumed by the kernel at boot time.

Dhall is a statically typed configuration language designed to be safe, programmable, and reproducible. It is a purely functional language with a strong type system and normalization semantics, primarily intended for generating configuration data such as JSON, YAML, or environment-specific templates.

DITA (Darwin Information Typing Architecture) is an XML-based documentation architecture used for structured technical documentation and publishing. It organizes content into reusable topics that are assembled using maps to produce manuals, help systems, and web documentation, typically processed by publishing pipelines and documentation tools that transform the source into formats such as HTML, PDF, and online help systems.

Djot is a lightweight markup language designed for writing structured documents in a simple, readable plain-text format. It is similar in purpose to Markdown but aims to provide a more consistent and unambiguous specification while remaining easy to write and parse. Djot supports common document features such as headings, lists, tables, links, and inline formatting, and is intended for use in documentation, publishing, and other text-based workflows.

Dockerfiles are build-description scripts used by Docker to construct container images. A Dockerfile consists of a sequence of declarative instructions (such as FROM, RUN, COPY, and CMD) that define the base image, filesystem contents, build steps, and runtime configuration of a container.

DockerCompose refers to configuration files used by Docker Compose to define multi-container applications. Compose files describe services, networks, volumes, and runtime configuration for containerized applications.

DOT is a graph description language used by the Graphviz visualization toolkit. DOT files describe graphs consisting of nodes and edges, along with optional attributes that control layout and rendering. DOT source files are commonly used to generate diagrams and network visualizations by Graphviz tools.

DTD (Document Type Definition) is a schema language used to describe the structure and permitted content of XML documents. A DTD specifies the allowed elements, attributes, and hierarchical relationships that an XML document must follow in order to be considered valid.

Dune is the configuration language used by the Dune build system for OCaml projects. Dune files describe build rules, libraries, executables, and other project configuration using a declarative syntax based on S-expressions. The build system reads these files to determine how to compile and link OCaml programs.

Dust is a templating language designed for generating dynamic text such as HTML in web applications. It emphasizes asynchronous rendering and streaming output, making it well suited for high-performance server-side environments. Dust templates separate presentation from application logic and are often used with JavaScript-based systems.

Dylan is a multi-paradigm, dynamically typed language designed in the early 1990s with the goal of combining, written at Apple. Modern Dylan uses an ALGOL-like infix syntax, though earlier versions experimented with Lisp-like syntax.

Earthfile is the build-description language used by the Earthly build system for reproducible containerized builds. Earthfiles describe targets and build steps using a syntax similar to Dockerfiles, combining container image instructions with dependency-aware build rules.

Earthfiles are commonly used in continuous integration pipelines and containerized software development environments.

ebuild is Gentoo’s package-build DSL, implemented as constrained shell-style scripts with package-manager conventions.

ECPP (Embedded C Pages) is a templating system used to generate dynamic web content by embedding C code within HTML-like documents, which are processed by a server-side engine that compiles the templates into C++ programs and executes them to produce web responses.

EditorConfig is a configuration-file format used to define coding style conventions for text editors and development environments. EditorConfig files describe formatting rules such as indentation, line endings, and character encodings that editors should apply when editing files in a project.

EditorConfig files are typically named ".editorconfig" and use a simple key/value syntax organized into sections describing file patterns.

EdgeQL is the query language of the EdgeDB database system. It is a declarative language for querying and manipulating strongly typed data using object-like path expressions rather than SQL-style tables and joins. Although it serves the same general role as SQL, its syntax is closer to functional expression languages and is designed to reflect the structure of EdgeDB’s schema and type system.

EDN (Extensible Data Notation) is a Clojure-family data DSL for structured literals and configuration-like data exchange.

Eiffel is a statically typed object-oriented programming language designed by Bertrand Meyer with strong emphasis on software correctness and design-by-contract. Programs include explicit preconditions, postconditions, and invariants used to enforce program correctness.

EJS (Embedded JavaScript) is a templating language used to generate HTML and other text formats by embedding JavaScript code within templates. Template files combine ordinary text with special tags such as "<% …​ %>" for script execution and "<%= …​ %>" for output. EJS is commonly used in Node.js web applications to render dynamic pages from server-side data.

Emacs Lisp (commonly called Elisp) is a dialect of Lisp used primarily to extend and customize GNU Emacs. It is a (now somewhat archaic) Lisp dialect.

Elixir is a functional, concurrent programming language built on the Erlang virtual machine (BEAM). It was designed to create scalable and fault-tolerant applications by leveraging Erlang’s proven concurrency model and runtime. Elixir features a modern syntax, powerful metaprogramming capabilities, and a robust ecosystem, and is commonly used for distributed systems, web applications, and real-time services.

Elvish is a modern Unix shell language designed as an alternative to traditional shells like Bash and Zsh. It combines interactive shell usability with a more structured, programmable language design.

Elm is a statically typed functional programming language designed for building reliable web user interfaces. Elm programs compile to JavaScript and emphasize immutability, pure functions, and a strict module system to eliminate many common runtime errors in front-end applications.

EmacsDevEnv refers to project configuration files used by the Emacs Development Environment (EDE), part of the CEDET toolkit for GNU Emacs. EDE files describe project structure, build targets, and source relationships used by Emacs for navigation, compilation, and development assistance. These files are typically named "Project.ede" or use the extension ".ede" and contain data structures written in Emacs Lisp syntax. Rather than executable programs, they are configuration objects defining project metadata.

Erlang is a functional programming language designed for building highly concurrent, distributed, and fault-tolerant systems. It was originally developed at Ericsson for telecommunications software and is known for its lightweight processes, message-passing concurrency, and robust supervision model.

ESDL (Energy System Description Language) is a domain-specific language for describing energy-system models and infrastructure layouts, including assets, networks, and flows. It is used in energy-system modeling tools to exchange structured descriptions of energy systems and scenarios.

Expect is a scripting language used to automate interactive programs such as command-line tools and network logins.

F# is a functional-first programming language in the ML family, originally developed for the .NET platform. Open-source compilers and tooling now support Windows, macOS, and Unix-like systems. It supports functional, object-oriented, and imperative programming styles and is commonly used for data analysis, modeling, tooling, and application development.

F* (F star) is a functional programming language designed for program verification. It combines ML-like programming with a rich dependent type system that allows programs to be annotated with logical specifications and formally verified. F* is used both as a general programming language and as a platform for proving correctness of security- and systems-critical software.

Factor is a stack-based, concatenative programming language inspired by Forth and Joy. It is dynamically typed and comes with a full-featured optimizing compiler and interactive development environment.

Euphoria is a dynamically typed programming language designed to be easy to learn while supporting structured programming and strong runtime type checking. It features a simple syntax and a core data structure called a sequence, which allows nested arrays and flexible data manipulation.

Fantom is a general-purpose, object-oriented programming language designed for portability across multiple runtime platforms, especially the JVM and JavaScript. It aims to combine the familiarity of C-family syntax with a concise design and strong support for component-based development.

Fennel is a Lisp dialect that compiles to Lua, designed to combine Lisp’s macro system and homoiconic syntax with the lightweight runtime and ecosystem of Lua. Fennel code is typically compiled ahead of time or at load time into ordinary Lua source, allowing it to run anywhere Lua runs.

fish (the Friendly Interactive SHell) is a Unix command interpreter designed to be more user-friendly than traditional shells such as Bourne shell or Bash. It emphasizes interactive usability features such as syntax highlighting, autosuggestions, and a simpler scripting syntax, while remaining compatible with common command-line workflows.

FlatBuffers is a serialization format and interface definition language developed by Google for efficient data exchange between programs. It allows structured data to be stored and accessed without requiring parsing or unpacking, enabling high performance and low memory overhead. FlatBuffers is commonly used in games, embedded systems, and other performance-sensitive applications.

Forth is a minimalist, stack-based programming language designed for interactive programming, extensibility, and close-to-the-metal control. It’s notable for getting a lot done on tightly constrained hardware,

Fortran (Formula Translation) is one of the earliest high-level programming languages, originally developed by IBM in the 1950s for scientific and numerical computation. It remains widely used in high-performance computing and scientific modeling. The language has evolved through many standards (Fortran 77, 90, 95, 2003, and later), adding structured programming, modules, and modern data types while retaining compatibility with older code.

"Fortran77" describes Fortran77 and older dialects with fixed-fields syntax

Fortran (Formula Translation) is one of the earliest high-level programming languages, originally developed by IBM in the 1950s for scientific and numerical computation. It remains widely used in high-performance computing and scientific modeling. The language has evolved through many standards (Fortran 77, 90, 95, 2003, and later), adding structured programming, modules, and modern data types while retaining compatibility with older code.

Fortran90 describes the newer free-format syntax.

FreeBASIC is a modern open-source BASIC dialect designed to be largely compatible with QuickBASIC while adding modern programming features. It compiles to native machine code and is used for systems utilities, games, and educational programming.

FreeMarker is a template DSL for generating text (often HTML) from data models in JVM-based applications.

Frege is a purely functional programming language for the Java Virtual Machine, inspired by Haskell and the ML family. It provides a strong static type system with type inference, algebraic data types, and lazy evaluation, while interoperating directly with Java classes and libraries.

FSL (Finite State Language) is a domain-specific language used to describe finite-state machines and related control logic. It provides a concise syntax for defining states, transitions, and actions, allowing developers to model event-driven behavior in systems such as protocol implementations, embedded software, and control systems. Tools that use FSL typically generate executable code or diagrams from the state-machine descriptions.

FXML is an XML-based language used by the JavaFX framework to define user interface layouts. It describes the hierarchy of UI components, their properties, and event handlers in a declarative form. FXML files are typically loaded by JavaFX applications at runtime and may be authored directly or generated using visual tools such as Scene Builder.

Futhark is a functional programming language designed for high-performance data-parallel computing, particularly on GPUs. Developed at the University of Copenhagen, it focuses on expressing parallel algorithms in a concise and predictable way while allowing the compiler to generate efficient low-level code. Futhark is often used for numerical computing and workloads that benefit from massive parallelism.

GAP (Groups, Algorithms, Programming) is a programming language and computer algebra system designed for computational discrete algebra, particularly group theory. It was developed in the 1980s and is maintained by an international research community.GAP programs manipulate algebraic structures such as groups, permutations, rings, and graphs. The language supports interactive computation as well as script-based programs and provides extensive libraries for algebraic algorithms and mathematical research.

GCode refers to the machine-control language used to operate CNC machines and 3D printers. G-code programs describe movements, tool changes, speeds, temperatures, and other machine operations using a sequence of commands interpreted by machine firmware. G-code files are widely used in manufacturing, machining, and additive manufacturing workflows.

Gambas (Gambas Almost Means BASIC) is an object-oriented programming language and development environment inspired by Visual Basic but designed for Linux systems. It provides a BASIC-style syntax together with modern features such as classes, modules, and GUI toolkits, making it suitable for desktop applications and scripting.

GDB command files are script files (sequences of GDB commands) used by the GNU Debugger to execute debugger commands non-interactively. They are commonly used to automate debugger setup, define breakpoints and command sequences, configure output, and initialize debugging sessions through files such as ".gdbinit".

GDScript is a high-level scripting language used with the Godot game engine. Its syntax is designed to be concise and readable, drawing inspiration from Python while integrating closely with Godot’s scene and node system. GDScript is commonly used to implement gameplay logic, control scenes, and interact with engine APIs in Godot projects.

GenCat NLS files are message catalog source files used by the POSIX internationalization system. They contain sets of numbered message strings that can be compiled by the "gencat" utility into binary message catalogs used by applications at runtime. Programs retrieve localized messages from these catalogs using the "catopen", "catgets", and "catclose" interfaces defined by the POSIX National Language Support (NLS) facilities.

Gherkin is a domain-specific language used for writing executable specifications in behavior-driven development (BDD). It provides a structured, human-readable syntax based on keywords such as Given, When, and Then to describe application behavior in terms of user interactions and expected outcomes. Gherkin scenarios are typically executed by tools such as Cucumber to link specifications with automated tests.

GitFastImport refers to the command stream format consumed by the "git fast-import" tool. Fast-import streams are used to efficiently create or modify Git repositories by feeding a sequence of commands that describe commits, file contents, branches, and tags. The format is commonly used by repository conversion tools and migration utilities to import history from other version-control systems.

Glade XML is the user-interface description format used by the Glade interface designer for GTK applications. A Glade file describes the hierarchy of widgets, properties, signals, and layout containers used to construct a graphical user interface. Programs load the file at runtime to instantiate the interface.

Gleam is a statically typed functional programming language designed for building reliable and maintainable systems on the Erlang/OTP platform. It compiles to Erlang and runs on the BEAM virtual machine, allowing Gleam programs to interoperate with Erlang and Elixir libraries while benefiting from BEAM’s concurrency and fault-tolerance model.

GlimmerJS is a JavaScript framework and templating language used for building reactive web user interfaces. Glimmer templates use an HTML-like syntax with embedded expressions written using Handlebars-style delimiters. These expressions bind template content to application data and control flow constructs such as conditionals and loops.

GlimmerTS refers to Glimmer component source files written with TypeScript using the Glimmer templating and component system from the Ember.js ecosystem. Glimmer components combine TypeScript code with template markup that describes reactive user-interface elements. GlimmerTS files define component logic using TypeScript syntax while embedding template expressions that bind data and control rendering of HTML-like structures. These files are compiled by the build toolchain into JavaScript and template code executed by the Glimmer rendering engine.

GLSL is the OpenGL shading language for programmable graphics-pipeline stages.

Gnuplot is a scripting language used by the Gnuplot plotting utility for generating graphs and data visualizations. Gnuplot scripts describe plots, data sources, styles, and output formats that the Gnuplot engine interprets to render charts such as line graphs, histograms, surface plots, and other scientific visualizations.

Go (often called Golang) is a statically typed, compiled programming language developed at Google for building reliable and efficient systems software. It combines a simple C-like syntax with built-in support for concurrency through goroutines and channels, and is widely used for network services, infrastructure tools, and distributed systems.

Godot Resource files are text-based asset definitions used by the Godot game engine. In the ".tres" format, resources are stored as structured key–value data describing engine objects such as materials, animations, and other assets. The format is designed to be human- readable and editable, allowing resources to be inspected and modified directly in text form. Godot also supports a binary variant (".res") for more compact storage of the same resource data.

Godot Scene files store the structure of scenes used by the Godot game engine. In the text-based ".tscn" format, a scene describes a tree of nodes, their properties, and references to external resources such as scripts, textures, and materials. Scenes are the primary organizational unit in Godot projects and can represent levels, user-interface layouts, or reusable game objects.

Gohtml refers to HTML template files written using the Go "html/template" templating language. These templates combine ordinary HTML markup with embedded expressions and control structures delimited by "{{" and "}}". The template engine evaluates these expressions when generating output, allowing dynamic data to be inserted into HTML documents.

GoTemplate refers to templates written using the Go "text/template" and "html/template" templating languages provided by the Go standard library. These template languages are used to generate text or HTML documents by combining static content with dynamically evaluated expressions.

Gradle is a build automation language and tool used to define how software projects are compiled, tested, packaged, and published. Gradle build scripts are typically written in a Groovy-based domain- specific language that provides constructs for declaring dependencies, configuring plugins, and defining build tasks. Gradle is widely used in the Java and Android ecosystems and supports multi-language builds.

Grails is a web application framework for the Java platform that uses the Groovy language and the Spring ecosystem to simplify development of database-driven web applications, with views typically written in Groovy Server Pages that combine HTML markup with embedded Groovy code and are processed by the Grails runtime to generate dynamic web content.

GraphQL is a query language and schema language for APIs, originally developed at Facebook. It allows clients to request precisely the data they need from a server and provides a strongly typed schema for describing available queries, mutations, and data types. GraphQL documents are typically used to express API queries and schema definitions rather than general-purpose programs.

Groovy is a dynamic programming language for the Java platform that integrates closely with existing Java code and libraries. It offers a more concise and flexible syntax than Java while supporting both dynamic and optional static typing. Groovy is commonly used for scripting, automation, and build systems, and it is widely known as the language used by the Gradle build tool.

Gwion is a programming language for sound synthesis and audio programming, descended from the ChucK family of strongly timed languages. It is designed for real-time audio work and emphasizes precise timing, extensibility, and a flexible object system while retaining a compact C-like syntax.

Haml is an indentation-based templating language used mainly for HTML generation in Ruby web stacks.

Hamlet is a templating language used by the Haskell Yesod web framework for generating HTML from structured templates. It combines HTML-like markup with embedded expressions and control constructs, which are compiled into Haskell code at build time.

Handlebars is a templating language for generating dynamic text, most commonly HTML, from data and templates. It extends the Mustache template syntax with features such as helpers, block expressions, and partials, allowing more complex template logic while maintaining a clear separation between presentation and application code. Handlebars is widely used in JavaScript applications for client-side and server-side rendering.

Happy is a parser generator for the Haskell programming language. It reads a grammar specification and produces a Haskell module that implements a parser for that grammar, typically using LALR(1) parsing techniques. Happy is commonly used for building compilers, interpreters, and other tools that need to process structured input.

References: https://hackage.haskell.org/package/happy

Hare is a statically typed systems programming language designed for writing operating systems, compilers, and other low-level software. It emphasizes simplicity, explicit resource management, and robust error handling while avoiding unnecessary language complexity.

Haskell is a statically typed functional programming language designed for expressive abstraction and mathematical clarity. It is based on non-strict (lazy) evaluation and a strong type system with type inference, algebraic data types, and higher-order functions. Haskell is widely used in research, compilers, and functional-programming education.

Haskell Boot files are auxiliary source files used by the Haskell compiler to break circular dependencies between modules. A boot file contains forward declarations of types, classes, and functions that a module exports, allowing other modules to reference those definitions before the full implementation is compiled. Boot files correspond to regular Haskell modules but are named with a different extension.

Haxe is a high-level, statically typed programming language designed for cross-platform development. A single Haxe codebase can be compiled to multiple targets, including JavaScript, C++, C#, Java, Python, and others. It is commonly used for game development, web applications, and tools where sharing code across different platforms is desirable

HCL (HashiCorp Configuration Language) is a configuration language designed for defining infrastructure and application settings in a human-readable form. It is widely used in HashiCorp tools such as Terraform, Consul, and Nomad to describe infrastructure resources and configuration data in a declarative style.

HEX refers to Intel HEX firmware image files used for representing binary programs in a textual hexadecimal encoding. The format is commonly used for distributing firmware for embedded systems and microcontrollers.

HEX files consist of records beginning with ":" followed by fields that encode byte count, address, record type, data bytes, and a checksum. The format represents raw binary data rather than source code.

Hjson (Human JSON) is a configuration and data format designed to be a more readable alternative to JSON. It preserves the JSON data model but allows comments, optional quoting, and simplified syntax for objects and arrays.

hledger is a plain-text accounting language used by the hledger double-entry accounting tools. hledger journal files describe financial transactions, account declarations, commodity settings, and other bookkeeping directives in a human-editable text format. The language is largely compatible with Ledger-style journal syntax and is used for personal and small-business accounting workflows.

HLSL (High-Level Shading Language) is a programming language developed by Microsoft for writing shaders used by the Direct3D graphics API. HLSL programs describe programmable stages of the graphics pipeline, such as vertex, pixel, geometry, and compute shaders, allowing developers to control how graphics hardware processes vertices, textures, and lighting. HLSL shares many features with other shader languages such as GLSL.

Hope is an early functional programming language developed in the late 1970s at the University of Edinburgh. It was designed to explore typed functional programming and introduced algebraic data types and pattern matching in a strongly typed setting. The language influenced later functional languages such as Miranda and the ML family. It has been superseded by ML and Haskell

Hibernate Query Language (HQL) is the object-oriented query language used by the Hibernate ORM framework for Java. It resembles SQL but operates on mapped entity classes and their properties rather than directly on database tables and columns.

HTML (HyperText Markup Language) is the standard markup language used to structure and describe documents on the World Wide Web. It defines elements such as headings, paragraphs, links, images, and forms using a tag-based syntax interpreted by web browsers. HTML documents often embed or reference other languages such as CSS and JavaScript.

HTML EEx is a templating format used in the Elixir ecosystem for generating HTML dynamically. It combines standard HTML with embedded Elixir expressions written between "<% …​ %>" delimiters, allowing templates to include logic, data interpolation, and control flow. HTML EEx templates are widely used in Elixir web frameworks such as Phoenix to render dynamic web pages.

HunspellAffix refers to affix files used by the Hunspell spelling engine. An affix file defines the encoding, flag format, and the prefix and suffix rules used to generate inflected or derived word forms from entries in a Hunspell dictionary. Hunspell affix files are commonly stored with the extension ".aff" and are used together with corresponding ".dic" dictionary files. They contain directives such as "SET", "FLAG", "PFX", and "SFX" that control how Hunspell interprets and expands dictionary entries.

HunspellDictionary refers to dictionary files used by the Hunspell spell-checking engine. Hunspell dictionaries define lists of words and optional morphological flags that control how words may be inflected or combined. These dictionaries are used by applications such as LibreOffice, Mozilla products, and many text editors to provide spelling and morphology checking.

Hurl is a domain-specific language used to define HTTP requests and assertions for testing web services. Hurl scripts describe HTTP methods, URLs, headers, request bodies, and expected responses in a concise textual format. Hurl are executed by the Hurl tool to run automated API tests and validate HTTP responses.

HyphenationPattern refers to hyphenation dictionary files used to describe where words may be broken across lines in text layout and typesetting systems. These files are used by hyphenation engines in office suites and publishing tools to apply language-specific hyphenation rules.

Hyphenation pattern files are commonly distributed as ".dic" files in language resource collections. They contain pattern-oriented data rather than ordinary word lists.

Hy is a Lisp dialect that runs on the Python platform. It combines the homoiconic, macro-based syntax of Lisp with direct access to Python’s runtime and libraries.

Icon is a high-level programming language designed for string processing and goal-directed evaluation. It was developed at the University of Arizona as a successor to SNOBOL and emphasizes concise expression of pattern matching, generators, and backtracking computation. Icon generators made their way into several later languages, including Python.

The Unicon language shares a file extension with Icon; if you see a report of both languages in your repository check them by hand.

Idris is a functional programming language with a full-spectrum dependent type system, designed to allow programs and proofs to be written in the same language. It belongs to the Haskell/ML family but extends the type system so that types can depend on values, enabling precise specifications and machine-checked proofs about programs.

Imba is a programming language designed for building web user interfaces. It combines a high-level syntax for defining components with embedded markup and reactive data binding, compiling to JavaScript for execution in web browsers.

INI is a simple configuration-file format used by many programs to store key–value settings grouped into named sections. The format originated in early Microsoft Windows systems but has since become a more widely used, loosely standardized convention for human-editable configuration files.

Inno Setup is a scripting language and toolset for building Windows installers. Scripts describe installation steps, user-interface pages, file placement, registry changes, and uninstall behavior. The language combines a declarative section format with an embedded Pascal-like scripting language and a simple preprocessor.

INTERCAL (Compiler Language With No Pronounceable Acronym) is an esoteric programming language created in 1972 by Don Woods and James Lyon as a parody of conventional programming-language design. It is notable for deliberately obscure syntax, unusual control constructs, and whimsical keywords such as PLEASE, DO, and ABSTAIN. INTERCAL is primarily of historical and recreational interest.

Io is a small, prototype-based programming language designed for simplicity, uniformity, and extreme conceptual minimalism. It was created by Steve Dekorte.

Isabelle is a generic proof assistant used for formal verification and interactive theorem proving. Developed at the University of Cambridge and the Technical University of Munich, it provides a framework for defining logical systems and mechanically checking mathematical proofs. Its most widely used instantiation, Isabelle/HOL, supports higher-order logic and is commonly used in formal methods, software verification, and mathematical formalization.

J is an array programming language designed by Kenneth Iverson and Roger Hui as a successor to APL. It retains the array-oriented style of APL but uses ASCII symbols instead of the special character set required by APL. J emphasizes concise expression of operations on arrays and matrices through tacit (point-free) programming and functional composition.

Jai is a systems programming language designed by Jonathan Blow with an emphasis on performance, simplicity, and direct control over program behavior. It targets game development and other performance-critical software, aiming to replace C/C++ workflows with a language that provides powerful compile-time metaprogramming and a more streamlined syntax.

Jam is a build system and build description language originally developed by Perforce Software. It was designed as an alternative to make, providing a more structured language for describing build rules and dependencies.

Janet is a small, embeddable Lisp dialect designed for systems programming and scripting. It provides a compact core language with data structures, macros, and a bytecode virtual machine, along with a standard library aimed at practical tasks such as networking, parsing, and file processing.

This is a family of languages originally designed to run insider browsers that has escaped that containment. Typescript is a syntactic superset of JavaScript.

JCL (Job Control Language) is the control language used on IBM mainframe systems to describe batch jobs and their execution environment. JCL statements specify which programs to run, the data sets they use, and the system resources required for execution. It is primarily a job-description format rather than a general-purpose programming language.

Jinja2 is a text-templating language most commonly used with Python, especially for HTML and configuration-file generation.

JOSS (JOHNNIAC Open Shop System) was an interactive time-sharing programming language developed in the early 1960s at RAND for the JOHNNIAC computer. It was designed for conversational use from a terminal, with numbered program steps and simple English-like commands for arithmetic, control flow, and input/output. It is now long extinct.

jq is a lightweight functional programming language designed for processing and transforming JSON data. It is commonly used as a command-line tool for querying, filtering, and restructuring JSON documents in shell pipelines and data-processing workflows.

JavaServer Faces (JSF) is a component-based web framework for the Java platform that generates dynamic web interfaces by combining XML-based view templates with server-side Java components, typically rendering HTML pages while integrating with Java EE or Jakarta EE application servers and back-end business logic.

JSLT is a transformation language for JSON data, conceptually similar to XSLT for XML. It allows JSON documents to be queried, filtered, and transformed into new JSON structures using functional expressions and built-in operators. JSLT is commonly used in data-processing pipelines and integration systems where structured JSON must be reshaped or aggregated.

JSON (JavaScript Object Notation) is a lightweight data-interchange format derived from the object-literal syntax of JavaScript. It is widely used for configuration files, data serialization, and communication between web services. JSON represents data as hierarchical structures composed of objects (name/value mappings) and arrays.

JSON5 is a human-friendly extension of JSON designed to make hand-edited data files easier to read and maintain. It is a superset of JSON that adds a small set of features borrowed from ECMAScript 5.1, while remaining suitable for structured data and configuration files. JSON5 files may use unquoted object keys when they are valid identifiers, single-quoted strings, trailing commas, hexadecimal numbers, leading or trailing decimal points, explicit plus signs, and both single-line and multi-line comments. Valid JSON is also valid JSON5.

JSONC (JSON with Comments) is a variant of the JSON data format that permits comments in configuration files. It is commonly used in development tools and editors such as Visual Studio Code to allow configuration files to include explanatory annotations.

Jsonnet is a data-templating language designed for generating JSON and other structured configuration formats. It extends JSON with expressions, functions, conditionals, and imports while preserving the ability to evaluate to ordinary JSON data. Jsonnet is commonly used in configuration-heavy environments such as Kubernetes deployments.

JSP (originally JavaServer Pages, now Jakarta Server Pages) is a server-side templating language used to generate dynamic web content in Java-based web applications. JSP documents combine HTML markup with embedded Java expressions, directives, and tag libraries.

JSX is an XML-like syntax extension for JavaScript, widely used for user-interface code, especially with React. It allows HTML-like markup to be embedded directly in JavaScript expressions and is normally translated to ordinary JavaScript by a compiler or transpiler.

Julia is a high-performance programming language designed for technical and numerical computing. It combines a dynamic, high-level syntax with a sophisticated type system and a just-in-time compiler that generates efficient native code. Julia is widely used for scientific computing, data analysis, and machine learning.

Julius is a JavaScript-templating language used by the Yesod web framework. It belongs to the Shakespeare family of templates (along with Hamlet, Cassius, and Lucius) and is designed to generate JavaScript with embedded expressions that are expanded at compile time into Haskell code.

Jupyter is an interactive computing environment that allows users to create and share documents containing live code, equations, visualizations, and explanatory text. Jupyter notebooks support many programming languages through a system of language kernels, with Python being the most widely used. The platform is commonly used in data science, scientific computing, education, and reproducible research.

Just is a command runner and build automation tool designed as a simpler alternative to Make. Justfiles define recipes consisting of named commands that can be executed from the command line. Recipes may depend on other recipes and typically contain shell commands. Justfiles are commonly used in Rust and modern development projects for running build tasks, tests, and development workflows.

K is a terse array programming language in the APL family, developed by Arthur Whitney. It is designed for concise expression of operations over arrays and tables and is widely used in financial and data analysis systems, particularly in environments related to the kdb+ database. Programs are typically short and rely heavily on symbolic operators and vectorized computation.

Kaem is a minimal command-interpreter language used in the Stage0 bootstrapping toolchain to drive the earliest phases of system compilation from a very small trusted base. It resembles a very small shell-like scripting language whose primary purpose is sequencing commands during bootstrap builds.

KDL (KDL Document Language) is a structured configuration language designed to provide a readable and extensible alternative to formats such as JSON, YAML, and TOML. It represents data as a tree of nodes, each of which may contain arguments, properties, and nested child nodes. KDL emphasizes simplicity of parsing while remaining convenient for human editing. KDL documents are often used for configuration files and application settings in modern tools such as terminal multiplexers and developer utilities.

Kotlin is a statically typed programming language developed by JetBrains for the JVM, Android, and multiplatform targets. It combines concise syntax with modern language features such as null-safety, extension functions, and coroutines, while maintaining full interoperability with Java libraries.

Kubernetes manifests are YAML documents used to define objects in a Kubernetes cluster such as pods, services, deployments, and volumes. They describe desired system state that the Kubernetes control plane works to maintain.

KVLang (also just "KV") is the declarative user-interface description language used by the Kivy framework. KV files describe widget hierarchies, layout rules, and property bindings that are loaded by Python applications at runtime to construct graphical user interfaces.

LALRPOP is a parser generator for the Rust programming language. It uses grammar specifications to produce efficient parsers, typically based on LR parsing techniques, and integrates closely with Rust’s type system and tooling. LALRPOP is commonly used for building compilers, interpreters, and other tools that process structured text.

Lean is a functional programming language and interactive theorem prover developed at Microsoft Research. It is used to write formal mathematical proofs and verified programs, combining a dependently typed functional language with an automated proof assistant.

Lem is a domain-specific language for writing formal specifications of programming languages and systems. It allows definitions of types, functions, and operational semantics that can be translated into several target languages, including OCaml, Coq, Isabelle/HOL, and HOL4. Lem is commonly used in research projects to describe and reason about language semantics and formal models.

Less is a stylesheet preprocessor language that extends CSS with variables, nesting, mixins, functions, and other constructs that make stylesheets easier to maintain and reuse. Less source files are compiled into standard CSS before being interpreted by web browsers.

LilyPond is a text-based music engraving language used to produce high-quality sheet music. A LilyPond document describes musical notation—such as notes, rhythms, staves, and articulations—using a domain-specific syntax that resembles traditional music notation. The LilyPond compiler processes these descriptions and generates typeset scores in formats such as PDF or PNG.

LinguaFranca (LF) is a programming language and framework for building reactive and time-sensitive systems. It is based on the reactor model, organizing programs as networks of components that communicate through events with explicit timing semantics. LinguaFranca is used for applications such as embedded software, cyber-physical systems, and distributed systems where deterministic execution and precise coordination are important.

GNU ld linker scripts are declarative control files for output sections and memory layout.

Liquid is a template language used for generating dynamic content in web pages and other text-based documents. It was originally created by Shopify and is widely used in static site generators, blogging platforms, and e-commerce systems such as Jekyll and Shopify themes.

Lisp is a family of programming languages characterized by symbolic expression (S-expression) syntax and the treatment of code as data. Originally developed in the late 1950s by John McCarthy, Lisp became one of the earliest high-level languages and has strongly influenced many later language designs. Lisp dialects vary widely but generally share a minimal core built around lists, functions, and macros.

LiveScript is a functional, expressive language that compiles to JavaScript. It evolved from CoffeeScript but emphasizes more powerful syntax, functional programming constructs, and conciseness.

LLVM IR (Intermediate Representation) is a low-level, platform- independent programming language used internally by the LLVM compiler infrastructure. It provides a typed, assembly-like representation of programs that serves as a common layer for analysis, optimization, and code generation across many source languages and hardware architectures. LLVM IR is widely used in compiler development and tooling.

Logo is an educational programming language designed to introduce children to programming concepts through exploration and visual feedback. It was developed in the late 1960s by Seymour Papert and colleagues at MIT.

Logtalk is an object-oriented logic programming language that runs on top of Prolog systems. It extends Prolog with constructs for objects, protocols, and categories while preserving compatibility with the underlying Prolog runtime. Logtalk is commonly used for modular logic programming, knowledge representation, and meta-programming.

Lua is a lightweight, embeddable scripting language designed for use as an extension language in applications. It was originally developed at PUC-Rio in Brazil and is widely used in game engines, embedded systems, and configuration scripting. Lua emphasizes a small core language with dynamic typing and a simple procedural syntax.

Luau is a programming language derived from Lua and used for scripting within the Roblox platform. It extends Lua with optional static typing, performance improvements, and tooling for large-scale game development.

M3U is a playlist file format used by media players and streaming systems to describe ordered lists of media resources, typically referencing local files or network streams that playback software loads and presents sequentially or according to embedded metadata.

m4 is a general-purpose macro processor originally developed for Unix systems. It processes input text by expanding macros and performing simple conditional and text-substitution operations, and is commonly used in build systems and configuration tools such as Autoconf.

MAD (Michigan Algorithm Decoder) was an early high-level programming language developed at the University of Michigan in the late 1950s for scientific and engineering computation. It provided a more readable and structured alternative to assembly language and was widely used on IBM mainframe systems in academic environments before being superseded by languages such as Fortran and Algol. It is extinct, but a partial retrocompiler exists.

Makefiles are build-description scripts used by the Unix "make" tool to specify how programs are compiled and linked. A Makefile defines targets, dependencies, and command sequences that describe how to produce files from other files. The language combines declarative dependency rules with embedded shell commands executed by the build system.

Mako is a templating language for Python that embeds Python code directly into text templates. It allows templates to include control structures, expressions, and function definitions using special delimiters such as "${…​}" for substitution and "<% …​ %>" for embedded Python code. Mako is commonly used in web frameworks and code-generation workflows where Python logic needs to be combined with generated text such as HTML or configuration files.

Mal is a small pedagogic Lisp with multiple implementations that follow the Make-A-Lisp process.

The Unix manual page format ("man") is a markup language used for writing online documentation viewed with the "man" command. It is based on the roff/troff typesetting system and uses macro commands to describe document structure such as sections, paragraphs, and lists.

Maple is a symbolic mathematics programming language used in the proprietary Maple computer algebra system. It supports symbolic computation, numerical analysis, and mathematical modeling through a high-level language designed for expressing algebraic and calculus operations.

Markdown is a lightweight plain-text markup language designed for writing formatted documents using a syntax that remains readable in raw text form. It was originally created by John Gruber for producing HTML from simple text documents and is now widely used for technical documentation, README files, and web publishing.

Mathematica (the Wolfram Language) is a proprietary symbolic programming language and computational environment developed by Wolfram Research for mathematics, scientific computing, and symbolic manipulation. It combines functional, rule-based, and procedural programming styles and is widely used in technical computing and computer algebra systems.

Maxima is an open-source computer algebra system and programming language for symbolic mathematics. It supports algebraic manipulation, calculus, differential equations, and many other forms of mathematical computation. The language is derived from the Macsyma system developed at MIT in the late 1960s.

Maven is a build and project-management system widely used in the Java ecosystem. Maven project files (typically "pom.xml") describe a project’s dependencies, build steps, plugins, and packaging in a structured XML document interpreted by the Maven tool.

MDX is an extension of the Markdown document format that allows embedded JSX expressions and components within Markdown content. It is commonly used in documentation systems, static site generators, and React-based content platforms to combine prose with interactive components.

Menhir is a parser generator for the OCaml programming language. It takes a grammar specification similar to Yacc and produces an efficient LR(1) parser implemented in OCaml. Menhir provides advanced features such as incremental parsing, detailed error reporting, and strong integration with OCaml’s type system, making it widely used for building compilers and language tools.

Mercury is a statically typed logic/functional programming language designed as a high-performance successor to Prolog. It adds a strong type system, mode system, and determinism analysis that allow Mercury programs to be compiled efficiently while preserving declarative semantics.

Mercury programs define modules, predicates, functions, and types using syntax derived from Prolog but extended with explicit type and mode declarations.

Meson is a build-system language and tool designed to provide fast and reliable builds with a simple, readable syntax. Meson build files ("meson.build" and ".meson" modules) describe project structure, dependencies, and compilation steps in a declarative style interpreted by the Meson build tool.

Metafont is a language developed by Donald Knuth for describing fonts and glyph shapes using mathematical formulas. It is part of the TeX typesetting system.

Mint is a statically typed programming language and framework for building single-page web applications. It compiles to JavaScript and integrates application structure, routing, and component-based user interfaces into a single language designed to simplify frontend development.

MIB (Management Information Base) modules describe the structure of management data used by the Simple Network Management Protocol (SNMP). They are written using the SMI (Structure of Management Information) language, a specification language derived from ASN.1. A MIB module defines managed objects, notifications, and data types used by network devices. Definitions specify object identifiers, syntax types, access permissions, and descriptive text that documents how management software can interact with the device.

Miranda was a purely functional programming language developed by David Turner in the mid-1980s. It was one of the first widely used lazy functional languages and strongly influenced the design of Haskell and other modern functional programming languages. It was superseded by Haskell.

ML is a family of statically typed functional programming languages originating in the 1970s at the University of Edinburgh. It introduced many concepts now common in functional programming, including type inference and algebraic data types. OCaml is one of its more notable descendants, and Standard ML is another.

Modelica is an object-oriented, declarative language for modeling large, complex, and heterogeneous physical systems. It is widely used for multi-domain engineering models involving mechanical, electrical, thermal, hydraulic, and control subsystems. Modelica programs are organized as classes describing equations, components, and connections rather than primarily as statement-oriented algorithms.

Modula is a structured programming language developed by Niklaus Wirth as a successor to Pascal, intended to support modular program construction and systems programming. It introduced the concept of separately compiled modules with explicit interfaces, allowing large programs to be organized into well-defined components.

Modula-2 is a structured, statically typed programming language designed by Niklaus Wirth as a successor to Pascal and Modula. It introduces a strong module system separating definition and implementation modules, making it suitable for systems programming and large software projects. Modula-2 influenced later languages such as Ada and Oberon.

Modula-3 is a systems programming language derived from Modula-2 and developed at DEC Systems Research Center and Olivetti Research in the late 1980s. It was designed to support safe systems programming while retaining strong modular structure, garbage collection, and exception handling. Modula-3 influenced later language designs through its combination of simplicity, type safety, and practical system-level features.

Mojo is a programming language developed by Modular AI for building high-performance machine-learning and numerical software. It combines a Python-like surface syntax with systems-programming capabilities similar to languages such as C++ and Rust.

MoonScript is a lightweight, expressive programming language that compiles to Lua. It was designed to provide a cleaner, more modern syntax while remaining fully compatible with the Lua ecosystem.

Motoko is a statically typed programming language designed for developing smart contracts on the Internet Computer platform. It was developed by DFINITY to provide a safe and expressive language for writing canisters (smart contract services) that run on the Internet Computer blockchain.

Move is a programming language designed for writing smart contracts and digital asset logic in blockchain systems. It was originally developed for Facebook’s Diem project and is now widely used in blockchain platforms such as Aptos and Sui. Move emphasizes safety and formal verification of resource usage, introducing a resource-oriented type system that prevents duplication or accidental destruction of digital assets.

MUMPS (Massachusetts General Hospital Utility Multi-Programming System), often called M, is a programming language and integrated database system originally developed in the 1960s for medical information systems. It combines a procedural language with a hierarchical key–value database and is still widely used in healthcare and other enterprise systems.

Mustache is a logic-less templating language used to generate dynamic text such as HTML from data and templates. It emphasizes simplicity by limiting templates to placeholders, sections, and partials, avoiding embedded programming logic. Mustache templates can be used across many programming languages and are commonly employed in web applications and document generation.

Nearley is a parser generator toolkit for JavaScript that allows developers to define grammars and automatically generate parsers. Nearley grammars are written in a declarative syntax similar to extended Backus–Naur Form (EBNF) and are compiled into JavaScript parsers.

NetLogo is a programming language and environment for agent-based modeling and simulation. It is widely used in scientific and educational contexts to study complex systems composed of interacting agents.

Nextflow is a workflow description language and execution framework used for building reproducible data-processing pipelines, especially in bioinformatics and scientific computing. Pipelines describe processes, data channels, and execution environments, allowing tasks to run locally, on clusters, or in cloud environments. The language is based on Groovy syntax with additional constructs for workflow orchestration and dataflow programming.

Nemerle is a statically typed programming language for the .NET platform that combines functional and object-oriented programming features with an extensive macro system.

Nickel is a configuration language designed for writing modular, typed, and composable configuration files. It combines a functional expression language with records, contracts, and merging operations, making it suitable for describing complex application and system configurations while remaining more structured and reusable than formats such as JSON or YAML.

NIL (New Implementation of Lisp) was a Lisp dialect developed at MIT in the 1970s as a successor to MacLisp.

Nim is a statically typed systems programming language designed for efficiency, expressiveness, and metaprogramming. It compiles to C, C++, or JavaScript and emphasizes readable syntax inspired by Python combined with powerful compile-time features such as macros and templates.

Nix is a functional configuration and package description language used by the Nix package manager and the NixOS operating system. Nix expressions describe software packages, system configurations, and build environments in a declarative and reproducible way. Nix files are typically used to define package derivations, system configurations, or reusable functions that generate build instructions. The language is lazily evaluated and supports functional abstractions, attribute sets, and list processing.

NSIS, the Nullsoft Scriptable Install System, is a scripting language used to build Windows installers. Scripts describe installer user interfaces, file installation, configuration actions, and uninstall behavior. The language combines a simple command syntax with a C-like preprocessor.

nuBASIC is a modern interpreter for a BASIC-like programming language, designed to preserve the simplicity of classic BASIC while providing a portable implementation for contemporary systems. It retains the traditional interactive and procedural style of BASIC, with commands and control structures intended to be easy for beginners to read and write.

Nunjucks is a templating language for JavaScript environments originally developed by Mozilla. It is heavily inspired by the Jinja2 template language used in Python and is commonly used in web applications and static site generators to produce HTML or other text documents. Nunjucks templates combine ordinary text or markup with embedded expressions and control structures. Expressions are written using "{{ …​ }}", control directives using "{% …​ %}", and comments using "{# …​ #}". Templates are interpreted by the Nunjucks engine and rendered with data provided by the host application.

Nushell is a modern command shell designed to replace traditional Unix shells with a more structured approach to data and pipelines. Instead of passing plain text between commands, Nushell pipelines structured data such as tables and records, allowing commands to operate on typed values rather than strings.

Oberon is a structured, statically typed programming language designed by Niklaus Wirth as a successor to Modula-2. It simplifies earlier Wirth languages while retaining strong modular structure and support for systems programming. Oberon was developed alongside the Oberon operating system and emphasizes clarity, safety, and a minimal language definition.

OCaml is a statically typed functional programming language from the ML family that also supports imperative and object-oriented programming styles. It features type inference, pattern matching, and a powerful module system, enabling the development of reliable and efficient software. OCaml is widely used in compilers, formal methods, financial systems, and other applications that benefit from strong type safety and performance.

occam is a concurrent programming language designed for the Transputer architecture. It emphasizes communicating sequential processes and deterministic parallelism.

GNU Octave is a largely compatible open-source implementation of the MATLAB language. MATLAB is a high-level programming language and numerical computing environment designed primarily for matrix-oriented computation, numerical analysis, and data visualization. Programs are written using a procedural syntax with built-in support for vector and matrix operations.

Odin is a systems programming language designed for simplicity, performance, and explicit control over program behavior. It provides a modern alternative to C with features such as strong typing, packages instead of complex build systems, and built-in support for data-oriented programming. Odin is commonly used in game development, tools, and other performance-critical software.

Ohm is a grammar specification language used to define parsers and interpreters. It is part of the Ohm-JS toolkit and is designed for describing formal grammars in a readable syntax while separating the grammar definition from semantic actions. Ohm grammars define parsing rules and alternatives using a notation similar to extended Backus–Naur Form (EBNF). Programs written in Ohm are typically processed by JavaScript tools that interpret the grammar and apply semantic operations defined separately.

OpenAPI refers to specification documents describing REST APIs using the OpenAPI Specification (formerly Swagger). These files define API endpoints, request and response formats, authentication mechanisms, and documentation metadata. OpenAPI documents are typically written in YAML or JSON and are used by tooling to generate documentation, client libraries, and server stubs.

OpenCL (Open Computing Language) is a framework and programming language for writing programs that execute across heterogeneous computing platforms such as CPUs, GPUs, and other accelerators. It was developed by the Khronos Group to provide a portable model for data-parallel computation across different hardware vendors.

OpenQASM (Open Quantum Assembly Language) is a domain-specific language for describing quantum circuits and programs for quantum computers. It was originally developed by IBM as part of the Qiskit ecosystem and is intended to serve as an intermediate representation between high-level quantum programming frameworks and low-level quantum hardware execution. OpenQASM programs describe quantum registers, classical registers, gate operations, and measurement steps that together define a quantum circuit.

OpenSCAD is a domain-specific language for describing 3D models using constructive solid geometry and parametric definitions. Instead of interactive modeling, OpenSCAD programs describe objects through scripts that combine primitives and transformations to produce geometric shapes.

OpenType Feature Files (".fea") are a DSL for defining OpenType layout behavior such as GSUB/GPOS substitutions and positioning.

Org mode is a plain-text outlining and authoring format used mainly in Emacs for notes, documents, and literate workflows.

Oz is a multi-paradigm programming language developed for research in programming-language design and declarative programming. It supports functional, logic, constraint, and concurrent programming within a single language framework. The language is most commonly associated with the Mozart/Oz system.

P4 is a domain-specific programming language for describing how network devices process packets. It allows developers to define the structure of packets and the behavior of the packet-processing pipeline in programmable switches, routers, and network interface cards. P4 is used in software-defined networking and other systems that require flexible, programmable data-plane behavior.

PacmanMakepkg refers to PKGBUILD files and related build descriptions used by the Arch Linux package-building tool "makepkg". A PKGBUILD is a Bash script containing the metadata and build instructions required to produce an Arch package. These files define package names, versions, dependencies, source locations, checksums, and build and packaging functions executed by "makepkg".

PAL was an extremely obscure academic language. RPAL was a pure-functional subset of PAL. Both used the same lexical syntax. Both very dead, but supported for historical reasons.

Pan is a declarative configuration language used by the Quattor toolkit to describe machine configurations and associated schemas. Pan templates define configuration values, validation rules, and structure for hierarchical configuration trees that are later compiled into machine-readable representations such as XML or JSON.

PARI/GP is a computer algebra system and programming language focused on number theory and algebraic computation. The GP language provides an interactive environment for performing symbolic and numerical calculations using high-precision arithmetic and specialized algorithms. PARI/GP programs typically consist of mathematical expressions, function definitions, and loops written in a concise scripting syntax.

Pascal is a structured programming language developed by Niklaus Wirth in the 1970s as a teaching language. It emphasizes clear syntax and strong typing and influenced later languages such as Modula and Ada.

Pawn is a small C-like scripting language designed to be embedded in host applications. Scripts are compiled to bytecode and executed by a lightweight virtual machine provided by the embedding program.

Peggy is a parser generator for JavaScript based on Parsing Expression Grammars (PEGs). It allows developers to define grammars in a concise PEG-based syntax and generates JavaScript parsers capable of recognizing structured text such as programming languages, data formats, and domain-specific languages. Peggy is the maintained successor to PEG.js and is commonly used in web and Node.js projects to build custom parsers and interpreters.

PEG.js is a parser generator for JavaScript based on Parsing Expression Grammars (PEGs). It allows developers to define grammars that describe the syntax of languages or data formats and generates a JavaScript parser from those definitions. PEG.js grammars can include embedded JavaScript code for semantic actions and are commonly used to build interpreters, compilers, and data parsers in web and Node.js applications.

Pek is a binary-format description language used by the GNU Poke programmable binary editor. Pek files describe the layout of binary data structures so that raw files can be inspected and edited as structured records.

Pest is a parser generator for the Rust programming language based on Parsing Expression Grammars (PEGs). It allows developers to describe grammars in a concise syntax and automatically generates parsers that integrate with Rust programs. Pest emphasizes readability and ease of use while providing tools for building compilers, interpreters, and other applications that process structured text.

Perl is a high-level, general-purpose programming language originally developed by Larry Wall for text processing and system administration tasks. It combines features of scripting languages and traditional programming languages, offering powerful regular expression support, dynamic typing, and extensive libraries. Perl has been widely used for web development, automation, and data processing.

Phix is a dynamically typed, general-purpose programming language derived from Euphoria and designed for simplicity and productivity. It compiles to native code and provides built-in support for tasks such as GUI development, database access, and scripting. Phix is often used for desktop applications, utilities, and rapid application development.

PHP (originally "Personal Home Page", now a recursive acronym for "PHP: Hypertext Preprocessor") is a server-side scripting language designed primarily for web development. PHP code is commonly embedded in HTML pages and executed by a web server to generate dynamic content. The language syntax derives largely from the C family.

Pic is a textual diagram-description language used with the troff toolchain, but can be rendered to SVG with third-party tools. It describes boxes, lines, arrows, circles, splines, and other drawing objects, and is processed by the pic preprocessor into troff or TeX drawing commands. Pic source is commonly embedded between .PS and .PE requests in roff documents, but also appears in standalone .pic files.

PILOT is an educational programming language designed in the 1960s for computer-assisted instruction. Programs consist of line-oriented commands used to present questions and evaluate responses. It was formerly standardized as IEEE Std 1154-1991, but this standard was withdrawn in 2000.

Pkl (pronounced "pickle") is a configuration language designed for writing safe, expressive, and composable configuration files. It was developed and open-sourced by Apple Inc.

PL/I (Programming Language One) is a general-purpose programming language developed by IBM in the 1960s with the goal of combining features of both scientific languages (such as Fortran) and business languages (such as COBOL). It provides a large and expressive feature set including strong typing, exception handling, and extensive data structures, and has historically been used in large enterprise and mainframe systems.

PL/M (Programming Language for Microcomputers) is an extinct systems programming language developed in the early 1970s for Intel microprocessors. It was designed as a high-level alternative to assembly language for writing operating systems, firmware, and other low-level software for early Intel processors. PL/M syntax resembles a simplified form of ALGOL or Pascal, with structured control flow and block constructs while allowing direct access to hardware and memory. The language was widely used for developing software for Intel 8-bit and 16-bit processors, including parts of the CP/M operating system.

PlantUML is a domain-specific language for describing diagrams using a simple textual syntax. It is widely used to generate UML diagrams such as sequence diagrams, class diagrams, activity diagrams, and state machines, as well as other visual documentation formats.

PlusCal is an algorithm language used to write specifications that are automatically translated into TLA+. It provides a procedural notation for describing distributed and concurrent algorithms that can then be verified with the TLC model checker.

PLYMesh refers to the Polygon File Format (PLY), a data format used for storing 3D geometry such as polygon meshes. PLY files describe vertices, faces, and other properties using a structured header followed by binary or ASCII data.

PO (Portable Object) files are text-based translation catalogs used by the GNU gettext internationalization system. They store original message strings and their translations in a structured format that allows software to display localized text at runtime.

Poke is the programming language used by the GNU Poke binary editor for inspecting, editing, and describing binary data. Poke programs define data structures, expressions, and commands that operate on binary objects and memory-mapped files. The language is commonly used to explore binary formats, implement binary data transformations, and automate inspection of structured binary data. Poke source files are typically stored with the extension ".pk".

Pony is a high-performance, actor-model programming language designed for safe concurrency without data races. It was created by Sylvan Clebsch and developed with support from Microsoft Research.

POP-11 is a programming language developed at the University of Sussex as part of the POPlog environment. It supports multiple programming paradigms including procedural, functional, and logic programming.

Portable Standard Lisp (PSL) is an implementation of the Lisp programming language designed to provide a portable and efficient runtime for symbolic computation systems. It was developed in the 1970s and 1980s to support computer algebra systems such as Reduce and to allow Lisp programs to run efficiently across multiple hardware architectures. It has been superseded in general use by Common Lisp, but is still deployed as the implementation language of the Reduce symbolic-algebra system.

PostCSS refers to stylesheets written for the PostCSS ecosystem, a toolchain for transforming CSS using JavaScript plugins. PostCSS itself is not a distinct stylesheet language but rather a framework that parses CSS and allows plugins to extend the syntax with new constructs, transformations, and preprocessing features.

PostScript is a stack-based programming language designed for describing printed pages and graphics. It was developed by Adobe Systems and became the standard page-description language used in printers and publishing systems. PostScript programs describe how text and graphics should be rendered rather than representing documents directly.

PowerShell is a task automation and configuration management framework that combines a command-line shell with a powerful scripting language. It was developed by Microsoft and is built on the .NET platform.

Prisma Schema is the configuration and data modeling language used by the Prisma ORM. It defines application data models, database connections, and client code generation settings for applications using the Prisma database toolkit.

Prolog is a logic programming language based on first-order predicate logic. Programs consist of facts and rules used by the interpreter to perform logical inference.

Processing is a programming language and development environment designed for visual arts, creative coding, and interactive graphics. Programs, known as sketches, are typically used to produce images, animations, and interactive media.

PromQL (Prometheus Query Language) is a domain-specific query language used by the Prometheus monitoring system to retrieve and analyze time-series metrics. It provides operators and functions for filtering, aggregating, and transforming metric streams, and is commonly used in dashboards and alerting rules.

Prometheus rule files are YAML documents containing recording rules and alert definitions that embed PromQL expressions. They are used by the Prometheus monitoring system to evaluate metrics queries and trigger alerts.

Protocol Buffers (often called Protobuf) is an interface-definition language and data-serialization format developed by Google. ".proto" files describe structured message types and remote procedure call interfaces that can be compiled into code for many programming languages. The resulting generated code is used to encode and decode compact binary messages.

ProGuard is a configuration language used to control the behavior of the Java bytecode shrinker, optimizer, and obfuscator implemented by the tool ProGuard. The language is a declarative rule format used in Java and Android build pipelines to specify which classes, methods, fields, and resources should be preserved, renamed, optimized, or ignored during bytecode processing.

PRQL (Pipelined Relational Query Language) is a domain-specific language for expressing database queries in a readable, composable form that compiles to SQL. PRQL queries are written as pipelines of transformations applied to relational tables, emphasizing clarity and maintainability compared to traditional SQL syntax. The language is commonly used as an intermediate representation for query generation in data-processing tools and analytics workflows.

PSL (Property Specification Language) is a formal assertion DSL for hardware/system property checking. It standardized under IEEE 1850.

Note that a couple of other languages bamed "PSL" have existed: Portable Standard Lisp, Profile Scripting Language, and Probabilistic Soft Logic.

Puppet is a declarative configuration-management language used by the Puppet automation platform to describe the desired state of systems. Puppet manifests define resources such as packages, services, files, and users, along with the relationships and dependencies between them. The Puppet agent evaluates these manifests and applies the necessary changes to bring a system into the specified state.

Pug is a template language used for generating HTML documents. It originated as the successor to the Jade templating language and is commonly used in Node.js web frameworks such as Express. Pug templates describe HTML structure using a concise indentation-based syntax that eliminates the need for explicit closing tags.

PureScript is a statically typed functional programming language that compiles to JavaScript. It is strongly influenced by the Haskell language and provides a rich type system with type classes, algebraic data types, and higher-kinded types. PureScript programs are typically used to build client-side web applications and other JavaScript-based systems while retaining strong static guarantees. Programs are compiled to JavaScript and executed in standard JavaScript environments such as web browsers or Node.js.

Pyret is an educational programming language designed for teaching data-centric programming and testing.

Python is a high-level, dynamically typed programming language designed for readability and rapid development. It emphasizes clear syntax, automatic memory management, and a large standard library. Python is widely used for scripting, web development, scientific computing, and automation.

QCL (Quantum Computation Language) is a programming language designed for describing quantum algorithms and quantum circuits. It was one of the earliest high-level languages developed specifically for quantum computing research and simulation.

QML is a declarative UI language in the Qt framework, typically used to define interface structure and behavior.

Qt Linguist is the translation system used by the Qt framework. The Qt Linguist tool operates on translation source files that store localizable text extracted from Qt applications. Translation source files normally use the .ts extension and are structured as XML documents. Each file contains a set of translation contexts corresponding to classes or UI components, with individual messages that map source strings to translated text.

qmake is the project description language used by the Qt build system to define how Qt applications and libraries are built. Project files describe source files, build targets, compiler options, and dependencies, and are processed by the qmake tool to generate platform-specific build files such as Makefiles or Visual Studio project files.

Quarto is a markup format used for creating reproducible documents that combine narrative text, executable code, and data analysis. Quarto documents extend Markdown with features for metadata, cross-references, citations, and executable code blocks. Quarto files are processed by the Quarto publishing system to generate output formats such as HTML, PDF, and presentations.

R is a programming language and environment used for statistical computing and graphics. It provides a wide range of statistical techniques and visualization tools and is widely used in data science and academic research.

Racket is a general-purpose programming language in the Lisp family, derived from Scheme and designed for language-oriented programming. It provides a rich macro system and a large standard library, making it suitable both for research and for practical software development.

Ragel is a state machine compiler used to generate efficient lexical analyzers and protocol parsers. Ragel source files describe finite state machines using a regular-expression–like notation combined with embedded host-language code. The Ragel compiler translates these descriptions into executable code in languages such as C, C++, Go, Rust, or Ruby. Ragel grammars define states, transitions, and actions using a notation similar to regular expressions and state machine diagrams. Embedded code blocks specify actions that run when transitions occur.

Rakefiles are Ruby-based build/task scripts used by Ruby’s "rake" tool, typically in files named "Rakefile".

Raku is a multi-paradigm language (formerly Perl 6) with rich grammar and regex support.

RAML (RESTful API Modeling Language) is a specification language for describing RESTful web APIs. RAML documents define endpoints, methods, parameters, request and response structures, and related metadata in a structured format built on YAML. It is primarily used for API design, documentation, and tooling generation rather than as a general-purpose programming language.

RapydScript is a Python-like programming language that compiles to JavaScript. It was designed to allow developers familiar with Python syntax to write code that targets the JavaScript runtime environment, particularly web browsers and Node.js.

Rascal is a domain-specific language designed for meta-programming, program analysis, and source-to-source transformation. It was intended for implementing compilers, interpreters, and software analysis tools. Rascal combines features from functional programming, pattern matching, and algebraic data types with built-in support for parsing, abstract syntax tree manipulation, and term rewriting. Programs written in Rascal can analyze source code, transform programs, and define domain-specific languages.

rc is the command shell used by the Plan 9 operating system. It was designed as a simpler and more consistent alternative to traditional Unix shells. rc uses list-valued variables, a simplified quoting model, and a cleaner grammar for control structures and pipelines.

ReasonML (often called just "Reason") is a programming language syntax for the OCaml language designed to resemble JavaScript-style syntax while retaining the powerful type system and functional programming features of OCaml. Reason programs compile to OCaml and can be used to produce native code or JavaScript,

Redex is a domain-specific language for specifying and experimenting with operational semantics of programming languages. It is implemented as a library for the Racket programming language and is widely used in programming-language research and teaching to define grammars, reduction relations, and evaluation rules.

REFAL (Recursive Functions Algorithmic Language) is a pattern-matching functional programming language originally developed in the 1960s for symbolic computation and program transformation. Programs consist of rules that rewrite expressions by matching patterns against input data and producing new expressions.

REBOL (Relative Expression-Based Object Language) is a scripting language designed for network communication and data exchange.

Reduce is a symbolic mathematics programming language and computer algebra system developed in the 1960s for algebraic and analytical computations and still alive today. It supports symbolic manipulation of expressions, polynomials, calculus operations, and other forms of mathematical analysis.

Rego is the DSL used to write policy modules written for Open Policy Agent (OPA) using the Rego policy language. Rego is a declarative language designed for expressing authorization rules, validation policies, and other decisions over structured data such as JSON documents, API requests, and configuration files. OPA evaluates these policy modules to answer queries about whether a given input satisfies the desired rules.

Ren’Py is a domain-specific scripting language used with the Ren’Py visual novel engine. Scripts define dialogue, scenes, menus, and game logic using a Python-like syntax combined with specialized statements for visual-novel presentation.

reStructuredText (reST) is a lightweight markup language designed for writing structured documents in plain text. It is part of the Docutils project and is widely used for technical documentation, particularly in the Python ecosystem. reStructuredText supports features such as sections, lists, tables, hyperlinks, and directives, and is commonly processed into formats such as HTML, PDF, and LaTeX.

ReScript is a statically typed programming language that compiles to JavaScript. It evolved from the ReasonML and OCaml toolchain and is designed to provide a familiar JavaScript-style syntax together with a strong static type system and fast compilation. ReScript programs are typically used for frontend and full-stack web development.

REXX (Restructured Extended Executor) is a scripting and macro language originally developed at IBM by Mike Cowlishaw. It was designed to be easy to read and write, with simple syntax and powerful string-processing capabilities. REXX has been widely used for system scripting and automation on mainframes, OS/2, and other operating systems.

Ring is a dynamically typed, general-purpose programming language designed for rapid application development and scripting. Ring programs are compiled to bytecode and executed by a virtual machine. The language is intended to be lightweight and embeddable and can be used for building desktop applications, web services, mobile applications, and domain-specific languages. Ring also allows customization of keywords, enabling programs that resemble natural language.

RMarkdown is a document format used for combining narrative text, data analysis, and executable code in a single source file. It is commonly used in the R ecosystem for reproducible research, documentation, and report generation. RMarkdown files are typically rendered into formats such as HTML, PDF, or Word documents by running the embedded code and incorporating its results into the generated output.

Robot Framework is an open-source automation framework that uses a keyword-driven domain-specific language to define test cases and acceptance tests, typically orchestrating external libraries and tools to drive user interfaces, APIs, or system components while producing structured test execution reports.

Rocq (formerly known as Coq) is a formal proof language used for reasoning about programs and mathematical systems.

nroff and troff are Unix text-formatting languages used for preparing manual pages and technical documents. Documents consist of plain text interspersed with formatting commands beginning with a period. Unix manual pages are written in a layer of macros over this format.

Roc is a statically typed functional programming language designed for building reliable applications with predictable performance. Programs are compiled ahead of time and run on host platforms using a system of platform interfaces that separate application logic from system integration.

RON (Rusty Object Notation) is a readable data-serialization format designed for the Rust ecosystem. It is intended to represent the full Serde data model in a syntax resembling Rust source code, including structs, enums, tuples, lists, maps, and primitive values.

RPG (Report Program Generator) is a programming language originally developed by IBM for business data processing on midrange and mainframe systems. Early versions emphasized report generation and fixed-format coding, while later variants such as RPG IV added modern structured programming constructs.

RPMSpecfile refers to specification files used by the RPM Package Manager to build binary and source packages. An RPM spec file describes how software should be compiled, installed, and packaged into an RPM archive. It also defines package metadata such as the name, version, release, dependencies, and description.

Rich Text Format (RTF) is a document file format developed by Microsoft for exchanging formatted text between different word-processing systems. It represents documents using plain text with embedded control words that describe formatting, structure, and metadata.

Ruby is a dynamically typed object-oriented scripting language designed by Yukihiro Matsumoto. It emphasizes programmer productivity and readable syntax and is widely used for web development, scripting, and automation.

RubyHTML (often called ERB templates) is a templating format used in Ruby web frameworks to embed Ruby code inside HTML documents.

Rust is a statically typed systems programming language designed for performance, memory safety, and safe concurrency. It was originally developed at Mozilla Research and is now maintained by the Rust Project. Rust combines C-like control over low-level resources with a strong type system and an ownership model that prevents many classes of memory errors at compile time.

SageMath is an open-source mathematical computing environment built on the Python programming language. It provides tools for symbolic algebra, number theory, calculus, combinatorics, and other areas of mathematics. Sage programs combine Python syntax with mathematical notation and high-level functions for symbolic and numeric computation. The system integrates many existing computer algebra and numerical libraries into a unified interface.

SaltStack states are configuration files used by the Salt configuration-management system to describe the desired state of systems. Written primarily in YAML with optional templating (often Jinja), ".sls" files define resources such as packages, services, files, and users, along with the conditions under which they should be created or modified. SaltStack uses these state definitions to automatically configure and maintain infrastructure.

SASL (St. Andrews Static Language) was an early, now extinct purely functional programming language from the 1970s. It was one of the first languages to use lazy evaluation as a central design feature and played an important role in the development of modern lazy functional programming languages. SASL programs define functions by equations and rely on expression evaluation rather than imperative control flow. The language influenced later functional languages such as KRC, Miranda, and ultimately Haskell.

Sass is a CSS preprocessor language, with both indented ".sass" syntax and CSS-like ".scss" syntax.

Sather is an object-oriented programming language influenced by Eiffel and designed for strong typing and high performance.

SCons is a software construction tool written in Python. Build descriptions are written as Python scripts that specify targets, dependencies, and build actions.

SCSS is a stylesheet language that extends CSS with variables, nesting, mixins, functions, and other constructs designed to simplify authoring large stylesheets. It is one of the syntaxes of the Sass preprocessor and is a superset of CSS, meaning any valid CSS file is also valid SCSS.

toolchains.

sed is a stream editor used for performing non-interactive text transformations on input streams or files. It applies editing commands sequentially to each line of input.

Seed7 is a general-purpose programming language designed to be easy to extend with user-defined statements and operators.

Self is a prototype-based object-oriented programming language developed at Xerox PARC in the late 1980s. Unlike class-based object systems, Self uses prototypes: objects inherit behavior directly from other objects rather than from classes. The language emphasizes message passing and dynamic object composition.

Self was highly influential in the development of modern virtual machine technology and dynamic language implementation techniques. Many optimization strategies used in modern JavaScript engines and the HotSpot JVM were first explored in Self.

SequenceL is a proprietary declarative programming language designed for data-parallel computation on sequences. Programs describe operations on lists or arrays using functional expressions rather than explicit loops, allowing the compiler to infer opportunities for parallel execution automatically.

SETL (SET Language) is a high-level programming language based on the mathematics of sets and predicate logic. It emphasizes high-level data structures such as sets, maps, and tuples.

SGML (Standard Generalized Markup Language) is a markup language for defining document structure and markup vocabularies. It served as the basis for HTML and XML.

The Unix shell scripting language family (including sh, bash, dash, and ksh) provides command execution and control-flow constructs for automating Unix system tasks.

Simula is a programming language developed in Norway in the 1960s and is widely considered the first object-oriented programming language.

SKILL is a Lisp-family scripting language used to customize and automate Cadence electronic design automation (EDA) tools. It is commonly used in integrated circuit design environments to generate layout geometry, manipulate schematics, control simulations, and extend tool functionality.

Slim is a lightweight templating language used primarily in Ruby web frameworks such as Rails and Sinatra. It is designed to generate HTML using a concise indentation-based syntax similar to Haml.

Snakemake is a workflow DSL for reproducible data-processing pipelines, built on Python syntax with rule-oriented constructs.

SNOBOL4 is a programming language designed for string manipulation and pattern matching. While it is now extinct in production use, key parts of its notation were carried forward in the regular-expression notation used by Unix tools such as sed and grep

Solidity is a programming language for writing smart contracts that run on the Ethereum blockchain.

Scala is a statically typed programming language that blends object-oriented and functional programming paradigms, running primarily on the Java Virtual Machine (JVM).

Scheme is a broad class of Lisp dialects distinguished by lexical scoping, first-class continuations, and a False bookean value distinct from the empty list.

Guile is a high-level, embeddable Scheme interpreter developed by the GNU Project. It is primarily designed to act as an extension and scripting language for applications.

Skew documentation describes it as a programming language for building cross-platform software. It compiles to straightforward, readable source code in other languages and is designed to be easy to integrate into a mixed-language code base. As of early 2026 it is still unstable and in development.

Slint is a declarative user-interface language used by the Slint UI toolkit for building graphical applications in Rust, C++, and other languages. Slint files describe interface layout, components, and bindings between UI elements and application logic. The language combines declarative UI definitions with embedded expressions and property bindings that control appearance and behavior.

Smalltalk-80 is a pure object-oriented programming language and development environment created at Xerox PARC in the 1970s, primarily by Alan Kay, Adele Goldberg, and Dan Ingalls. It is no longer in common use, but heavily influence the development of later object-oriwnted languages.

SML (Standard ML) is a statically typed functional programming language belonging to the ML family of languages. It was designed as a standardized version of the ML language originally developed for the LCF theorem prover, and emphasizes strong static typing, pattern matching, algebraic data types, and type inference.

SparForte is a scripting language derived from Ada and designed for secure system administration and automation tasks. It combines Ada’s strong typing and reliability features with scripting conveniences such as dynamic data structures, shell integration, and built-in database and networking capabilities. SparForte is used for writing administrative scripts and secure automation tools while retaining many of the safety properties associated with Ada.

Specman e is a hardware-verification DSL used for constrained-random testbench development. While it originated as a proprietary product, there is some open-source tooling for e.

SPICE is a circuit-netlist language for analog/mixed-signal circuit simulation (the simulator family, not the modern systems language).

Spice is a systems programming language with C-family syntax (distinct from the circuit-simulator SPICE format above).

Squirrel is a lightweight, high-level scripting language designed for embedding in applications, particularly games. Its syntax is similar to languages such as C, C++, and JavaScript, and it supports features including object-oriented programming, dynamic typing, and automatic memory management. Squirrel is commonly used as an embedded scripting language to allow customization and extension of host applications.

SQL (Structured Query Language) is a declarative language used for managing and querying relational databases.

SRecode is a template and code-generation system used within GNU Emacs, primarily as part of the CEDET development environment. SRecode templates are used to generate boilerplate code, file headers, and other structured text by expanding predefined templates with context-specific values.

Stan is a probabilistic programming language used for statistical modeling and Bayesian inference. It allows users to specify complex statistical models and perform inference using algorithms such as Hamiltonian Monte Carlo and variational inference. Stan is widely used in statistics, data science, and scientific research, and interfaces with languages such as R, Python, and Julia.

Stratego is a rule-based program-transformation DSL, commonly used in the Spoofax language-workbench ecosystem.

Starlark is a deterministic configuration and extension language derived from Python. It was originally developed by Google for the Bazel build system and is now used by several tools that require a safe, hermetic scripting language. Starlark programs resemble Python syntax but remove features that could introduce nondeterminism, such as unrestricted recursion, reflection, or access to external resources. The language is commonly used to define build rules, configuration files, and domain-specific extensions in systems such as Bazel, Buck, and Tilt.

Stylus is a stylesheet language that compiles to CSS. It was designed to provide a more concise and flexible syntax than ordinary CSS, adding features such as variables, mixins, functions, nesting, and arithmetic expressions. Stylus permits both a CSS-like syntax using braces and semicolons and a more compact indentation-based syntax. Stylus source files are commonly used in web-development toolchains to generate CSS stylesheets from higher-level source text.

SubversionDump refers to repository dump files produced by the "svnadmin dump" command of the Apache Subversion version-control system. These files contain a serialized representation of the complete history of a Subversion repository or a portion of it, and can be used to recreate or migrate repositories using tools such as "svnadmin load".

SugarSS is an indentation-based syntax for CSS designed to work with the PostCSS ecosystem. It removes the need for braces and semicolons, using indentation and line breaks to define CSS rules and declarations. SugarSS allows developers to write CSS in a cleaner, more concise form while still leveraging the wide range of PostCSS plugins and tooling.

SurrealQL is the query language used by the SurrealDB multi-model database. It resembles SQL but operates on SurrealDB records and supports document-style fields, graph traversal, and nested data structures within queries.

SVG (Scalable Vector Graphics) is an XML-based language for describing two-dimensional vector graphics.

Svelte is a component-oriented frontend DSL that compiles declarative components into JavaScript/CSS.

Swift is a statically typed programming language developed by Apple for iOS, macOS, and other Apple platforms.

SWIG interface files define bindings from C/C++ APIs to higher-level languages.

SystemVerilog is a hardware description and verification language used to design, model, and test digital systems. Standardized as IEEE 1800, it extends Verilog with additional constructs for hardware design as well as features for verification such as object-oriented programming, assertions, and constrained random testing. SystemVerilog is widely used in ASIC and FPGA development for both register-transfer level (RTL) design and testbench creation.

Tcl (Tool Command Language) is a dynamic scripting language commonly used for embedding in applications and for writing GUI programs using the Tk toolkit.

Teal is a statically typed dialect of Lua designed to add type checking while preserving Lua’s lightweight, embeddable style. It extends Lua with type annotations, records, interfaces, union types, and generics, and is compiled to plain Lua source. Teal is intended for projects that want stronger tooling and earlier error detection without giving up compatibility with the Lua ecosystem.

Tera is a template language used primarily in the Rust ecosystem for generating HTML, XML, and other text-based documents. It is inspired by the Jinja2 and Django template languages and is commonly used in Rust web applications and static-site generators.

Terra is a low-level systems programming language designed to be embedded inside Lua. It combines Lua’s metaprogramming capabilities with a statically typed language that compiles to native code using LLVM. Terra programs typically consist of Lua scripts that generate and execute Terra functions defined with the "terra" keyword. The Terra language uses C-like syntax and is often used for high-performance computing, domain-specific languages, and graphics programming.

TeX is a typesetting system created by Donald Knuth for producing high-quality technical and scientific documents. It provides precise control over document layout, particularly for mathematical typesetting, and forms the foundation for widely used macro packages such as LaTeX. TeX documents are written in a markup-like language that describes the structure and formatting of the text.

Texinfo is a documentation language used by GNU projects to generate online manuals and printed documentation.

Textile is a lightweight markup language designed for writing formatted text using a simple plain-text syntax. It was created by Dean Allen and was widely used in content management systems and collaborative publishing platforms.

Thrift (also known as Apache Thrift) is an interface-definition language used to describe data types and RPC service contracts for cross-language code generation.

Titanium Style Sheets are used by the Appcelerator Titanium framework to define styling rules for user interface components in mobile applications, providing a CSS-like mechanism that is interpreted by the Alloy framework and applied to UI elements defined in application views at runtime.

TLA+ is a formal specification language used to describe and verify the behavior of concurrent and distributed systems. Developed by Leslie Lamport, it is based on temporal logic and allows engineers to model system behavior and check properties such as safety and liveness. TLA+ specifications are commonly analyzed using the TLC model checker to detect design errors before implementation.

TNDSL (The Next Domain-Specific Language) is a domain-specific language used to describe data models and APIs in a structured, machine-readable form. It is designed to support code generation and documentation workflows by defining entities, relationships, and service interfaces in a concise specification language. TNDSL descriptions can be processed by tools to generate client libraries, server scaffolding, and related artifacts.

TOML (Tom’s Obvious, Minimal Language) is a configuration file format designed to be easy for humans to read and write while remaining simple to parse by machines. It uses a structured syntax with key-value pairs, tables, and arrays to represent configuration data. TOML is widely used in software projects for configuration files, notably in tools such as Cargo for the Rust programming language.

Turing is a programming language developed at the University of Toronto for teaching computer science concepts.

TSX refers to TypeScript source files that contain JSX syntax. It is used primarily with React and similar JavaScript frameworks to define user-interface components that combine TypeScript logic with HTML-like markup. TSX files allow developers to write JSX expressions directly inside TypeScript modules, which are then compiled into ordinary JavaScript.

TTCN (Testing and Test Control Notation) is a programming language used for defining automated test suites for communication protocols and distributed systems. TTCN is standardized by ETSI and ITU-T and is commonly used in telecommunications testing environments to describe test cases, message exchanges, and expected system behavior.

Twig is a template language used primarily with the PHP Symfony framework for generating HTML and other text formats. Twig templates combine ordinary markup with embedded expressions and control structures that are evaluated when rendering output.

Plain text; no assumptions about comments or other syntax.

Nefore ".adoc" became established, ".txt" was used as an extension for AsciiDoc files.

TypeScript is a statically typed programming language developed by Microsoft that compiles to JavaScript. It extends JavaScript with optional static typing, interfaces, modules, and other language features intended to improve large-scale application development. TypeScript programs are typically compiled into standard JavaScript for execution in browsers or other JavaScript environments.

Typst is a modern typesetting system and markup-based programming language designed for creating technical and scientific documents. It combines a concise markup syntax with programmable layout features, enabling users to automate formatting and generate complex documents such as papers, reports, and books. Typst aims to provide a simpler and more interactive alternative to traditional systems like TeX.

Umka is a statically typed scripting language designed for simplicity, portability, and embedding. It was created as a lightweight compiled language with syntax inspired by Go and C. Umka programs compile to bytecode executed by a small virtual machine, making the language suitable for scripting, extension languages, and lightweight applications.

Unicon is a high-level programming language derived from Icon and extended with object-oriented features, networking, and graphical user interface support. It preserves Icon’s goal-directed evaluation model while adding modern programming constructs and system libraries.

The Icon language shares a file extension with Unicon; if you see a report of both languages in your repository check them by hand.

Unison is a functional programming language with a content-addressed codebase and integrated tooling workflow.

UrWeb is a statically typed functional programming language designed for building web applications. It extends the Ur language with built-in support for typed HTML, SQL, RPC, and client/server interaction, allowing one program to describe browser-side code, server-side code, and database access in a single language.

UrWebProject refers to project configuration files used by the Ur/Web web programming system. These files describe how an Ur/Web application should be compiled, including the modules that make up the program, database configuration, and other build parameters.

Vala is a programming language designed to bring modern language features to the GNOME platform while compiling to C.

Velocity is a template language used by the Apache Velocity template engine for generating HTML and other text-based documents. It is commonly used in Java applications to render web pages, emails, configuration files, and code-generation templates by combining static text with dynamically evaluated expressions and directives. Velocity templates are typically stored with the extension ".vm".

V is a statically typed compiled programming language designed for simplicity, safety, and fast compilation. It is syntactically similar to languages in the C family but incorporates modern features such as optional garbage collection, immutable-by-default variables, and a minimalistic language design intended to keep compilation and tooling fast.

Verilog is a hardware description language used to model digital systems such as integrated circuits. Its successor is SystemVerilog.

VHDL is a hardware description language used for modeling and simulating digital systems.

Vimscript (also called VimL) is the built-in scripting language of the Vim text editor. It is used to configure, extend, and automate Vim’s behavior.

Virgil is a statically typed programming language designed for embedded systems and resource-constrained devices. It was developed as part of the VICE research project at the University of California, Los Angeles, to support efficient compilation and predictable execution on small microcontrollers.

Visual Basic is a family of programming languages developed by Microsoft, designed to make Windows application development accessible and rapid. While strongly associated with Windows, open-source implementations on Unix systems do exist.

VRML (Virtual Reality Modeling Language) is a language for describing 3D scenes and interactive environments.

Vyper is a contract-oriented programming language designed for writing smart contracts on the Ethereum blockchain. It emphasizes simplicity and security by limiting language features and providing a syntax similar to Python with strong static typing. Vyper programs define contract state variables and functions using decorators such as "@external" and type annotations for values stored on-chain. The language compiles to Ethereum Virtual Machine bytecode.

Vue refers to Vue Single-File Components (SFCs), the component format used by the Vue.js JavaScript framework for building user interfaces. A Vue component combines template markup, JavaScript or TypeScript logic, and CSS styles within a single file that describes a reusable user-interface component.

waf is a build-system framework used to configure, compile, and install software projects. Build descriptions are written as Python scripts (commonly named "wscript") that define targets, dependencies, and build steps executed by the waf tool.

Because waf build files are ordinary Python programs augmented with waf-specific helper APIs, they follow Python lexical syntax.

OBJ refers to the Wavefront OBJ 3D geometry file format used to describe polygon meshes and associated data such as vertices, texture coordinates, and surface normals. OBJ files are widely used in computer graphics, CAD tools, and game engines for exchanging geometric models.

A near superset of wat syntax that is more convenient for human developers to write directly. Note: this is not WASM!

WebIDL (Web Interface Definition Language) is a specification language used by web standards to describe the interfaces exposed by web browsers to JavaScript and other scripting environments. WebIDL definitions specify objects, attributes, methods, and types that form the Web APIs used by web applications.

WGSL (WebGPU Shading Language) is the shader language standardized for the WebGPU graphics API.

wish is the graphical shell for the Tcl/Tk toolkit. Programs executed by wish are Tcl scripts that create and manipulate graphical user interfaces using the Tk widget library. It is commonly used for building simple GUI applications and rapid interface prototypes.

Because wish scripts are written in Tcl, they use the same lexical syntax as the Tcl language.

WiX, the Windows Installer XML Toolset, is a domain-specific language for building Windows installation packages. Source files are written in XML and describe installation components, files, registry entries, and user-interface elements. WiX source is compiled into Windows Installer packages using the WiX toolchain.

Web Services Description Language (WSDL) is an XML-based language used to describe network services and the messages they exchange. It defines the operations provided by a web service, the structure of request and response messages, and the protocols and endpoints used to access the service. WSDL is commonly used with SOAP-based web services to enable automated client generation and service integration.

xBase is a family of database programming languages derived from dBASE that are used to build data-centric applications operating on DBF database files, with implementations such as dBASE, Clipper, FoxPro, open-source xHarbor, and related systems providing compatible languages and tools that integrate query, data manipulation, and user-interface logic around the underlying database engine.

XC is a C-derived programming language developed by XMOS for programming their multicore, event-driven embedded processors (the XMOS xCORE architecture). It extends C with built-in constructs for concurrency, communication, and real-time control.

XHTML (Extensible HyperText Markup Language) is a reformulation of HTML using XML syntax. It was developed by the W3C to combine the structure and semantics of HTML with the strict syntax rules of XML. XHTML documents must follow XML well-formedness rules, including properly nested elements, explicit closing tags, and quoted attributes.

XMI (XML Metadata Interchange) is a standard defined by the Object Management Group for exchanging metadata and models between software tools. It is most commonly used to serialize UML models and other MOF-based metadata structures.

XML (Extensible Markup Language) is a markup language for encoding structured documents and data. It provides a general framework for defining custom document formats.

DocBook is an XML vocabulary designed for writing technical documentation such as manuals and books.

XPL0 is a simplified programming language derived from XPL and used primarily in compiler construction education. XPL itself was a small subset of PL/I designed for implementing compilers, and XPL0 further reduces the language to a minimal instructional form. The language was at one lime widely used in compiler textbooks and teaching materials.

XQuery is a query and transformation language for XML data used to retrieve and manipulate structured information stored in XML databases, document stores, and web services, typically working alongside technologies such as XPath and XSLT within XML processing pipelines.

XSD (XML Schema Definition) is a schema language used to describe the structure, data types, and constraints of XML documents. An XML Schema defines the permitted elements, attributes, and content of an XML document, allowing XML processors to validate documents against the schema.

XSL (Extensible Stylesheet Language) is a family of XML-based languages used to transform and format XML documents. The most widely used component is XSLT (XSL Transformations), which defines rules for converting XML documents into other XML formats, HTML, or text. XSL stylesheets are written as XML documents that describe template rules and formatting instructions applied to an input XML tree.

Xtend is a statically typed programming language developed as part of the Eclipse Xtext ecosystem. It is designed primarily for code generation and domain-specific language tooling, compiling to Java source code that can be executed on the Java Virtual Machine.

Yabasic (Yet Another BASIC) is a simple interpreted BASIC dialect designed for portability and ease of use. It was originally created by Marc-Oliver Ihm and is commonly used for small utilities and scripting tasks. Yabasic retains the straightforward syntax of classic BASIC while adding structured programming constructs.

YAML (YAML Ain’t Markup Language) is a human-readable data serialization format commonly used for configuration files and data exchange. It uses indentation and simple syntax to represent structured data such as mappings and lists. YAML is widely used in software development and infrastructure tools, including configuration systems, container orchestration platforms, and build pipelines.

YANG is a data modeling language used to define configuration and operational data structures for network devices. It is commonly used with the NETCONF and RESTCONF management protocols to describe device configuration schemas and remote management operations.

Yorick is an interpreted, array-oriented programming language designed for numerical computing and scientific visualization. It was developed in the 1990s by David H. Munro for scientific research applications.

Yul is a low-level intermediate language used by the Solidity compiler for generating and optimizing Ethereum Virtual Machine bytecode. It provides a simple structured syntax resembling assembly language while supporting functions, variables, and control flow constructs. The language is primarily used as an intermediate representation for smart contract compilation and optimization.

Zencode is a domain-specific scripting language used by the Zenroom ecosystem for cryptographic workflows.

Zephir is a high-level programming language designed for writing PHP extensions. It allows developers to implement PHP extensions in a safer and more expressive syntax that is then compiled to C and built into native PHP modules. Zephir was created by the Phalcon framework project to simplify extension development.

Zig is a systems programming language designed for robustness, optimality, and maintainability.

ZoKrates is a domain-specific language and toolchain for writing and verifying arithmetic circuits used in zero-knowledge proofs, particularly for zkSNARK-based blockchain applications. Programs are compiled into constraint systems and proving/verifying artifacts.

zsh is a Unix command shell with advanced scripting and interactive features.