# -*- mode: yaml -*-
#
# The traits table in loccount.go is generated from this YAML.
#
# For a detailed guide to adding a language, see the file hacking.adoc
# in the source distribution.  You probably also want to read the
# design-notes.asc file.
# 
# All the language-specific information this program needs to know to do
# its job is the syntax of comments, string literals, and (if your
# language has them) regular-expression literals.
# 
# This code recognizes languages by file extension, Require checks, Forbid
# checks, and verifiers.  You can add support simply by appending an
# initializer here.
# 
# You may add multiple entries with the same language name, but extensions
# must be unique across all tables - *except* that entries with verifiers or
# Require or Forbid checks may share extensions with each other and with one
# trailing entry that has no verifier or Require or Forbid.
# 
# If a language has # as a line-comment leader and the file is
# executable, the code checks for a hashbang line matching either the
# langage name or suffix before checking the suffix on the path name.
# 
# Require/Forbid checks are expensive, so extensions that need
# them go after after extensions that don't. Order is significant in that
# section; it contains entries the recognizer will fall through to if a
# verifier/Require check fails.
#
# If you have multiple entries for an extension, (a) all the entries
# with verifiers or Require checks should go first, and (b) there should be at most one
# entry without a verifier or Require (because any second and later ones will be
# pre-empted by it).  Run loccount -s to check this property; if it's
# violated you get a message on stderr.
#
# Note that extension and filename comparison is caseblind!
#
# Here are the top-level attributes:
#	aka:         Common alternate names for the language
#       description: Text description of the language.
#       links:       Optional labeled URLs related to the language.
#       base:        Shared traits for every variant of a multivariant language.
#       variants:    Mapping from variant name to per-variant recognizer traits.
#
# Here are the attributes:
#
#	Name:     The language name.  Must not contain whitespace
#	Ext:      Case-insensitive suffixes beginning with . used
#	          for recognizing languages.
#	Files:    A list of case-insensitive exact basenames used for
#	          recognizing languages.
#	She:      A list of interpreter names used for shebang recognition.
#	Bc:       A list of begin/end string pairs for comments
#                 If a list element has a third (property) member and
#                 it is "cnest", that pair nests, e.g. like "(*" "*)" in
#	          Pascal. If a property is "sol", the leader and trailer
#	          are required to start at beginning of line. If one is "re"
#	          If one is "re", the opener is a regexp, and the first match group
#	          is substituted for "&" in the closing delimiter. Line comments
#	          are represented as pairs ending with "\n".
#	Str:      String literal pairs. Additional trailing members are pair
#	          properties; if one is "bse", backslash can be used to escape
#	          the starter. If one is "ml", the string can have newlines in it.
#	          Multiple pair properties may also be combined as an unquoted
#	          string using "|", e.g. ml|bse.
#	          If one is "outdent", the closer may be empty and the string ends
#	          when a later nonblank line outdents to the opener's indentation.
#	          If one is "re", the opener is a regexp, and the first match group
#	          is substituted for "&" in the closing delimiter. If one is "sol",
#	          the closing delimiter must begin a line.
#	          If one is "ind", whitespace may precede a line-start closer.
#       Co:       Complexity checks. Keyword lists, orginally from scc, for
#	          computing a poor man's cyclmatic compexity check.
#	Fl:       Quirk flags
#	Rx:       Tokens after which / may begin a regular-expression literal.
#	St:       Statement-terminating punctuation
#	Sb:       Statement-block start delimiter regexp (not yet used)
#	Eb:       Statement-block end delimiter regexp (not yet used)
#	Lrb:      Regular expression that marks the beginning of a non-code region.
#	          When a line matches Lrb, subsequent lines are treated as non-code.
#	Lre:      Regular expression that marks the end of a non-code region.//
#	          When a line matches Lre, normal parsing resumes after that line.
#	Lrx:      Regular expression that suppresses Lrb/Lre transitions on matching
#	          lines. This is typically used to prevent false region entry/exit,
#	          e.g. inside heredocs or other constructs where Lrb/Lre patterns
#	          may appear but should be ignored.
#	          (Not yet used).
#	Require:  List of regexes; at least one must match file contents
#	          Somre requires are commented out.  These are not necessary because
#	          the entry is unique bty suffix and having no require checks makes
#	          recognition faster, but they might be needed in the future.
#	Forbid:   List of regexes; none can match file contents
#
# Omitted attributes default to the empty string, meaning the language has
# no such syntax.
#
# On each start of non-whitespace, the order of syntax checks is:
# multiString, inlineString, blockCommentStart.  So, for example, you
# can declare lua's comment leader to be --[[ and [[ as a multiline
# literal start without a false match.
#
# Require and Forbid declarations are per-line regexps, so ^ and $ are
# effective. Multiple Require patterns are conjunctive: all must match
# somewhere in the file. Forbid patterns are disjunctive: if any matches
# a line, recognition fails. To get a disjunctive effect for Require,
# separate alternatives with | inside individual pattern elements.
#
# Backslashes are interpreted by Golang's JSON reader, so you will
# have to double them in the specification.
#
# The Like capability is special.  It is never shipped in the output;
# Instead, if an entry has a Like field it is taken to be the name of a previous
# entry which supplies defaults for this one.
#
# Some apparent omissions make more sense if you understand that the
# recognizer only needs to know about string syntax if either (a) the language
# has block comments or (b) it has multiline string literals. If neither of
# there is true, it doesn't matter if a comment leader is inside a string
# Thus, for example, Logo has no explicit string-pair entries despite having a string syntax.
# In cases like this, the references file may describe string syntax anyway.
#
# Some quirk notes:
# * XML has no explicit string-pair entries because quotes can occur in text bodies
#   without being string delimiters. (Could be fixed with a custom parser!)
# * HTML has to be declared without explicit string-pair entries to avoid issues with embedded JavaScript
# * Vim script has to be declared without explicit string-pair entries because comments are strings.
# * The FORTH lack of explicit string-pair entries means the parser can be fooled by unbalanced parens
#   in string literals. Alas, it would take a significant parser
#   extension to fix this.
#
# The only non-ASCII characters in this file are the APL UTF-8
# winged-comment leader (expressed as a hex escape) and some
# complexity-check UTF-9 chracters in Raku.
#
# How to use "-like" entries: These describe syntax families and are intended
# to be inherited with De. They never have file extensions. If a file
# extension is shared across a language family (e.g .prg for xBase databases)
# replicate it in all of them, but each one other than possibly the last
# should have distinguishing Require/Forbid entries.Do not create a family entry
# unless it earns its keep by factoring common syntax, comment forms, string
# rules, or other structural properties across multiple entries.
#

flags:
  bse: "Backslash escapes string delimiter"
  end: "Everything after __END__ is treated as comment."
  erlang: "$ escapes a following double quote"
  eur: "Apostrophe between digits is a numeric separator"
  f77: "Fortran 77 comment syntax"
  f90: "Fortran 90 comment syntax"
  heredoc: "heredoc detection suppresses comment syntax"
  ind: "String closer may be indented"
  ign: "Do not list as a separate language in -l or -s mode"
  ktl: "Don't complain about line comments ending at EOF without a newline"
  lex: "Has Lex-like %% sections"
  lit: "Haskell-style literate comments"
  ml: "String literal can contain newlines"
  outdent: "String literal ends when indentation outdents to the opener level"
  re: "Pair opener is a regexp"
  num: "Ignore line numbers"
  sol: "Comment or string closer must begin at start of line"
  tcl: "String starts only when preceded by punctuation or whitespace"
  yaml: "Use YAML line and block-scalar counter"
  xcpp: "Uses C preprocessor"
  xssep: "Uses a statement separator, not terminator"
  xlsbc: "Leading triple-quote string should be counted as a comment"
  xtsmc: "Module comments are triple-quoted strings"

classes:
  doc: "documentation format"
  xaud: "sound generation and processing DSL"
  xbld: "build-system DSL"
  xcfg: "configuration-management DSL"
  xctr: "smart-contract, blockchain, and proof-system DSL"
  xhdl: "hardware definition/fabrication DSL"
  xidl: "interface-definition DSL"
  xirf: "compiler IR and low-level toolchain format"
  xmat: "mathematical DSL"
  xmdl: "model and diagram DSL"
  xpld: "parser/lexer DSL"
  xqry: "query DSL for DBs or data pipelines"
  xser: "data-serialization format"
  xshd: "shader DSL"
  xtst: "test and executable-specification DSL"
  xtpl: "templating DSL"
  xtrn: "transformation and code-generation DSL"
  xdsl: "DSL (unclassified)"

status:
  xdead: "dead"
  xprop: "proprietary"

languages:
    # Re-usable parts
  C-like:
    source:
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
  Lisp-like:
    source:
      Str: [['"', '"', ml|bse]]
      Bc: [[;, "\n"]]
  XML-like:
    source:
      Bc: [["<!--", "-->"]]
  YAML-like:
    source:
      Str: [['"', '"', bse], ["'", "'"], ['(?:[|>](?:[1-9][+-]?|[+-][1-9]?|))[ ]*(?:#.*)?\n', '', ml|re|outdent]]
      Bc: [['#', "\n"]]
      Fl: yaml
  roff-like:
    source:
      Bc: [[.ig, ..], [.\", "\n"]]
      Fl: doc
  VBA-like:
    source:
      Str: [['"', '"']]
      Bc: [["'", "\n"], [REM, "\n"], [rem, "\n"]]
  Pascal-like:
    source:
      Bc: [[(*, '*)', cnest], ["{", "}"], [//, "\n"]]
      Sb: begin
      Eb: end
      Str: [["'", "'"]]
      Fl: xssep
  Haskell-like:
    source:
      Bc: [['{-', '-}', cnest], [--, "\n"]]
      Str: [['"', '"', bse]]
  SQL-like:
    source:
      Bc: [[/*, '*/'], [--, "\n"]]
      Str: [["'", "'", ml], [$$, $$, ml]]
  JavaScript-like:
    source:
      Like: C-like
      Str: [['`', '`', bse|ml]]
      Rx: ['(', '[', '{', '=', ':', ',', ';', '?', '!', '~', '+', '-', '*', '/', '%', '&', '|', '^', '<', '>', return, throw, case, yield, await, typeof, delete, void, new, in, of, instanceof, else, do]
  Python-like:
    source:
      Str: [['"""', '"""', bse|ml], ["'''", "'''", bse|ml], ['"', '"', bse], ["'", "'", bse]]
      Fl: xlsbc
      Bc: [['#', "\n"]]
  Shell-like:
    source:
      Str: [['"', '"', ml|bse], ["'", "'", ml], ['<<([A-Za-z_][A-Za-z0-9_]*)', '&', ml|re|sol]]
      Bc: [['#', "\n"]]
  JSON-like:
    source:
      Str: [['"', '"', bse]]
      Fl: xser
  ML-like:
    source:
      Bc: [[(*, '*)', cnest]]
      Str: [['"', '"', bse]]
  Ruby-like:
    source:
      Bc: [[=begin, =end, sol], ['#', "\n"]]
      Str: [['<<([A-Za-z_][A-Za-z0-9_]*)', '&', ml|re|sol], ['<<"([^"\n]+)"', '&', ml|re|sol], ['<<''([^''\n]+)''', '&', ml|re|sol], ['<<`([^`\n]+)`', '&', ml|re|sol], ['<<[-~]([A-Za-z_][A-Za-z0-9_]*)', '&', ml|re|sol|ind], ['<<[-~]"([^"\n]+)"', '&', ml|re|sol|ind], ['<<[-~]''([^''\n]+)''', '&', ml|re|sol|ind], ['<<[-~]`([^`\n]+)`', '&', ml|re|sol|ind], ['(?:b)?r(#{0,255})"', '"&', ml|re], ['"', '"', ml|bse], ["'", "'", ml|bse]]
      Rx: ['(', '[', '{', '=', ':', ',', ';', '?', '!', '~', '+', '-', '*', '/', '%', '&', '|', '^', '<', '>', return, when, then, if, unless, while, until, rescue, ensure, and, or, not, do]
      Fl: end
  Tcl-like:
    source:
      Str: [['"', '"', bse]]
      Fl: tcl
      Bc: [['#', "\n"]]
  # Languages
  ABAP:
    description: |-
      ABAP is the primary application programming language of the SAP
      enterprise platform.  It was developed as the programming language of
      the R/3 system and remains the core language used for developing
      business applications, reports, data transformations, and system
      extensions inside SAP environments. Not marked proprietary because
      an open-source ABAP to JavaScript transpiler exists.
    links: {Introduction: https://en.wikipedia.org/wiki/ABAP, Reference: https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm}
    source:
      Ext: [.abap]
      Bc: [['*', "\n", sol], ['"', "\n"]]
      Str: [["'", "'"], ['`', '`'], ['|', '|', bse]]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  ABC:
    description: |-
      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.
    links: {Website: https://homepages.cwi.nl/~steven/abc/}
    source:
      Ext: [.abc]
      Str: [['"', '"']]
      Bc: [[\, "\n"]]
  ABNF:
    description: |-
      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.
    links: {Reference: https://www.rfc-editor.org/rfc/rfc5234}
    source:
      Ext: [.abnf]
      Co: ['=/ ', '/ ', '% ', '( ']
      Fl: xpld
      Bc: [[;, "\n"]]
  Ada:
    description: |-
      Ada (programming language) is a statically typed, compiled
      language designed for high-reliability and safety-critical
      systems, emphasizing strong typing, modularity (packages),
      explicit concurrency (tasks and protected objects), and rigorous
      compile-time and runtime checks; originally developed under the
      U.S. Department of Defense, it is widely used in aerospace,
      defense, and other domains where correctness, maintainability,
      and long-term stability are essential.
    links: {Reference: http://www.ada-auth.org/arm.html}
    source:
      Ext: [.ada, .adb, .ads, .pad]
      St: ;
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[--, "\n"]]
  Agda:
    description: |-
      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.
    links: {Reference: https://agda.readthedocs.io/en/latest/language/lexical-structure.html}
    source:
      Ext: [.agda]
      Bc: [['{-', '-}', cnest], [--, "\n"]]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  AIDL:
    aka: ['Android Interface Definition Language']
    description: |-
      AIDL is the interface definition language used by the Android platform
      to define inter-process communication interfaces for the Binder IPC
      system.  An AIDL specification describes the methods that a remote
      service exposes along with the structured data types passed between
      client and service.

      AIDL is part of the Android Open Source Project and is used within
      Android system components and applications that require structured
      Binder-based IPC.
    links: {Reference: https://source.android.com/docs/core/architecture/aidl}
    source:
      Ext: [.aidl]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  Alda:
    description: |-
      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.
    links: {Website: https://alda.io/}
    source:
      Ext: [.alda]
      Fl: xaud
      Bc: [['#', "\n"]]
  Alex (Eclipse):
    description: |-
      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.
    links: {Reference: https://diverse-project.github.io/alex/}
    source:
      Ext: [.alex]
      Like: C-like
      St: ;
  AliceML:
    description: |-
      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.
    links: {Reference: https://www.ps.uni-saarland.de/alice/}
    source:
      Ext: [.aml]
      Like: ML-like
  Amber:
    description: |-
      Amber is a high-level scripting language designed to compile into
      POSIX shell scripts.  It provides structured programming constructs
      such as variables, conditionals, loops, and functions while targeting
      shell execution environments.  Programs are compiled into portable
      shell code, allowing developers to write maintainable scripts without
      manually handling the complexities and quirks of traditional shell
      syntax.
    links: {Website: https://amber-lang.com/, Repository: https://github.com/amber-lang/amber}
    source:
      Ext: [.amber]
      She: [amber]
      Str: [['"', '"']]
      Co: ['for ', exited(, 'failed ', failed(, 'succeeded ', 'if ', 'then ', 'while ', 'loop ', 'else:', 'else ', 'or ', 'and ', '!= ', '== ']
      Bc: [['#', "\n"]]
  ANTLR:
    description: |-
      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.
    links: {Website: https://www.antlr.org/}
    source:
      Ext: [.g4]
      Bc: [[/*, '*/'], [//, "\n"]]
      St: ;
      Fl: xpld
  APL:
    description: |-
      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.
    links: {Website: https://aplwiki.com/}
    source:
      Ext: [.apl]
      Str: [["'", "'"]]
      Co: [':For ', ':If ', ':Case ', ':CaseList ', ':While ', ':Repeat ', ':Else ', ∨, ∧, ≠, '~', ¨, '=', ':']
      Bc: [[⍝, "\n"]]
  Algol 60:
    description: |-
      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.
    links: {Reference: https://www.masswerk.at/algol60/report.htm}
    source:
      Ext: [.alg]
      Bc: [["COMMENT\n", ";\n"], [COMMENT, "\n"]]
      St: ;
      Sb: BEGIN
      Eb: END
      Fl: xdead
  Algol 68:
    description: |-
      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.
    links: {Reference: https://www.masswerk.at/algol68/report.html}
    source:
      Ext: [.a68]
      Bc: [[COMMENT, COMMENT]]
      St: ;
      Sb: BEGIN
      Eb: END
      Co: ['IF ', 'ELIF ', 'ELSE ', 'FOR ', 'WHILE ', 'CASE ', 'OUSE ', 'AND ', 'OR ', 'EQ ', 'NE ', 'IS ', 'ISNT ', 'IS NOT ', '~= ']
      Fl: xssep|xdead
  Alloy:
    description: |-
      Alloy is a declarative modeling language for relational structures,
      typically analyzed with the Alloy Analyzer.
    links: {Reference: https://alloytools.org/spec.html}
    source:
      Ext: [.als]
      Bc: [[/*, '*/'], [--, "\n"]]
      Co: ['implies ', 'else ', 'for ', '|| ', '&& ', '!= ', '== ', '<= ', '>= ']
      Fl: xmdl
  Ant:
    description: |-
      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.
    links: {Reference: https://ant.apache.org/manual/}
    source:
      Files: [build.xml]
      Like: XML-like
      Fl: xbld
  Nginx:
    aka: ['nginx configuration file']
    description: |-
      Nginx configuration files define directives and nested contexts that
      control the Nginx web server and reverse proxy. Configurations are
      commonly split across nginx.conf and included files, with directives
      setting HTTP, stream, server, location, upstream, logging, TLS, proxy,
      and FastCGI behavior.
    links: {Reference: https://docs.nginx.com/nginx/admin-guide/basic-functionality/managing-configuration-files/}
    base:
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Fl: xcfg
    variants:
      by file:
        Ext: [.nginx, .nginxconf]
        Files: [nginx.conf]
      by shared vhost suffix:
        Ext: [.vhost]
        Require: ['^\s*(?:server|location|upstream|http|stream|events)\s*(?:\{|[^;{]*\{)|\b(?:listen|proxy_pass|fastcgi_pass|server_name|root|ssl_certificate)\b']
  ApacheConf:
    aka: [aconf, apache, 'Apache config']
    description: |-
      ApacheConf refers to plain-text configuration files used by the
      Apache HTTP Server. These files contain directives that configure
      server modules, virtual hosts, directory and URL scopes, access
      control, logging, rewrites, and other HTTP server behavior.
      Per-directory .htaccess files use the same syntax for decentralized
      configuration inside served directory trees.
    links: {Reference: https://httpd.apache.org/docs/current/configuring.html}
    base:
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Fl: xcfg
    variants:
      by file:
        Ext: [.apacheconf]
        Files: [.htaccess, apache2.conf, httpd.conf]
      by shared vhost suffix:
        Ext: [.vhost]
        Require: ['<VirtualHost\b|\b(?:ServerName|DocumentRoot|Directory|DirectoryMatch|Location|LocationMatch|ProxyPass|RewriteRule|Alias|ErrorLog|CustomLog)\b']
  AppArmor:
    aka: ['AppArmor profile']
    description: |-
      AppArmor profiles are declarative policy files for the Linux
      AppArmor security module. They define named confinement profiles and
      rules that grant or deny access to files, capabilities, network
      sockets, mounts, signals, and other resources. Profiles may also use
      variables, aliases, includes, and flags, and are normally stored
      under /etc/apparmor.d.
    links: {Reference: https://apparmor.net/man/5.0/apparmor.d/}
    source:
      Ext: [.apparmor, .aa]
      Bc: [['#[ \t]', "\n", re]]
      Str: [['"', '"', bse]]
      Fl: xcfg
  AppleScript:
    description: |-
      AppleScript is a proprietary scripting language developed by Apple for
      automating applications and system functions on the classic Mac OS and
      later macOS platforms.  It is designed around an event-based model in
      which scripts send commands to applications that expose scriptable
      interfaces.
    links: {Reference: https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptLangGuide/}
    source:
      Ext: [.applescript, .scpt]
      Bc: [['(*', '*)'], ['--', "\n"]]
      Str: [['"', '"']]
      Co: ['considering ', 'ignoring ', 'repeat ', 'while ', 'if ', 'else ', 'else if ', 'try ', 'on error ', 'and ', 'or ']
      Fl: xprop
  Arc:
    description: |-
      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.
    links: {Website: https://arclanguage.github.io/}
    source:
      Ext: [.arc]
      Like: Lisp-like
  Aria:
    description: |-
      Aria is a text-based format used for structured linguistic and
      phonological annotation, typically in field linguistics workflows. It
      is designed to represent hierarchical and feature-based analyses of
      language data, supporting the organization of lexical items and their
      associated descriptive attributes.
    links: {Reference: https://software.sil.org/aria/}
    source:
      Ext: [.ari]
      Str: [['"', '"', ml]]
      Fl: xser
      Bc: [[;, "\n"]]
  Arturo:
    description: |-
      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.
    links: {Website: https://arturo-lang.io/}
    source:
      Ext: [.art]
      Str: [['"', '"']]
      Co: ['loop ', 'map ', 'select ', 'if ', 'if? ', 'while ', 'function ', 'or? ', 'and? ', 'not? ', '<> ', '= ']
      Bc: [[;, "\n"]]
  Arduino C++:
    aka: ['Arduino Sketch']
    description: |-
      Arduino C++ (also known as Arduino Sketch) 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.
    links: {Reference: https://docs.arduino.cc/language-reference/}
    source:
      Ext: [.ino]
      Like: C-like
      St: ;
      Fl: xcpp
  ArkTS:
    description: |-
      ArkTS is a strongly typed programming language used for application
      development on Huawei's HarmonyOS. It is designed as a statically
      typed dialect of TypeScript tailored for the Ark runtime and UI
      framework used in HarmonyOS applications. While closely tied to
      HarmonyOS, it is open source.
    links: {Reference: https://developer.huawei.com/consumer/en/doc/harmonyos-guides/arkts-overview}
    source:
      Ext: [.ets]
      Like: JavaScript-like
      Co: ['for ', for(, 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '!== ', '== ', '=== ', 'case ', 'case(', '?.', '?? ', '??= ']
  AsciiDoc:
    description: |-
      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.
    links: {Reference: https://docs.asciidoctor.org/asciidoc/latest/}
    source:
      Ext: [.adoc]
      Fl: doc
      Bc: [[//, "\n", sol]]
  asm:
    aka: [Assembly]
    description: |-
      loccount reports "asm" for anything it identifies as assembler source
      code by file extension, because identifying instruction sets reliably
      is beyond it.
    source:
      Ext: [.asm, .s]
      Bc: [[/*, '*/'], [;, "\n"], ['*', "\n"], [//, "\n"], ['#', "\n"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  ASN.1:
    description: |-
      ASN.1 (Abstract Syntax Notation One) is a formal interface-description
      language used to define structured data for protocols and file formats.
    links: {Reference: https://www.itu.int/rec/T-REC-X.680}
    source:
      Ext: [.asn, .asn1]
      Str: [['"', '"']]
      Fl: xidl
      Bc: [[--, "\n"]]
  AspectJ:
    description: |-
      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.
    links: {Website: https://www.eclipse.org/aspectj/}
    source:
      Ext: [.aj]
      Like: C-like
      St: ;
  Asymptote:
    description: |-
      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.
    links: {Website: https://asymptote.sourceforge.io/}
    source:
      Ext: [.asy]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
      Fl: xmdl
  Astro:
    description: |-
      Astro is a web framework and component format for building content-rich
      sites. Astro component files combine frontmatter script code with HTML
      template markup, optional client-side framework islands, and static or
      server-rendered output. The ".astro" source format is used for pages,
      layouts, and reusable UI components in Astro projects.
    links: {Reference: https://docs.astro.build/en/basics/astro-components/, Repository: https://github.com/withastro/astro}
    source:
      Ext: [.astro]
      Like: JavaScript-like
      Bc: [["<!--", "-->"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', '.map']
      Fl: xtpl
  ATS:
    description: |-
      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.
    links: {Website: https://ats-lang.sourceforge.net/}
    source:
      Ext: [.dats, .hats, .sats, .atxt]
      Bc: [[(*, '*)', cnest], ['/*', '*/'], [//, "\n"]]
      Str: [['"', '"']]
      Co: ['if ', if(, ' then ', ' else ', 'case+ ', ifcase, 'let ', 'and ']
  Autoconf:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/automake/manual/}
    base:
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
    variants:
      script:
        Ext: [.ac]
        Files: [autogen.sh, configure.in]
        Bc: [['#', "\n"]]
      templates:
        Ext: [.in]
        Bc: [[/*, '*/'], [//, "\n"]]
  AutoHotkey:
    description: |-
      AutoHotkey is a scripting language for Microsoft Windows designed for
      automation of user interface actions, keyboard shortcuts, and system
      tasks.  It is widely used to create custom hotkeys, text expansions,
      and automation scripts that control applications through simulated
      input and window manipulation.
    links: {Reference: https://www.autohotkey.com/docs/}
    source:
      Ext: [.ahk]
      Bc: [[/*, '*/'], [;, "\n"]]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  AXAML:
    aka: [AvaloniaXaml]
    description: |-
      AXAML (aka AvaloniaXaml) is the declarative markup language used by
      the Avalonia UI framework for defining user interfaces, resources,
      styles, and data bindings in cross-platform .NET applications. It
      follows the same general design model as XAML in other .NET UI stacks,
      adapted for Avalonia's architecture and portability goals.

      This is not the same language as XAML, though they are
      functionally similar.
    links: {HTML Documentation: https://docs.avaloniaui.net/docs/xaml/, Repository: https://github.com/AvaloniaUI/Avalonia}
    source:
      Ext: [.axaml]
      Like: XML-like
      Fl: xidl
  Avro:
    description: |-
      Avro is a language-neutral data serialization system developed within
      the Apache Hadoop ecosystem.  It is designed for compact binary data
      exchange and persistent storage with schemas defined separately from
      encoded data.  Systems written in different programming languages can
      communicate by sharing the same schema definitions. Avro is widely
      used in distributed data systems, particularly in the Apache Kafka and
      Hadoop ecosystems, for efficient schema-driven data interchange.
    links: {Website: https://avro.apache.org/}
    source:
      Ext: [.avsc, .avpr, .avdl]
      Like: JSON-like
  AWK:
    aka: [Awk]
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/gawk/manual/}
    source:
      Ext: [.awk]
      She: [awk, gawk, mawk, nawk]
      Str: [['"', '"', bse]]
      Co: ['else ', 'for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
  BaCon:
    description: |-
      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.
    links: {Website: https://www.basic-converter.org/}
    source:
      Ext: [.bac]
      Like: VBA-like
  Bait:
    description: |-
      Bait is a modern experimental programming language with a compiled
      toolchain and multiple backends, including JavaScript and C. It aims
      to balance simplicity and safety, featuring immutability by default
      and explicit error handling constructs. The language is under active
      development and is intended for general-purpose use, though it is
      still incomplete and evolving.
    links: {Repository: https://github.com/bait-lang/bait}
    source:
      Ext: [.bt]
      Str: [['"', '"']]
      Co: ['for ', 'if ', 'else ', ' or ', ' and ', '!= ', '== ']
      Bc: [[//, "\n"]]
  Ballerina:
    description: |-
      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.
    links: {Reference: https://ballerina.io/spec/lang/master/}
    source:
      Ext: [.bal]
      St: ;
      Str: [['`', '`', bse|ml], ['"', '"', bse]]
      Bc: [[//, "\n"], ['#', "\n"]]
  bash:
    aka: [BASH, 'Bourne Again Shell']
    description: |-
      Bash, the Bourne Again Shell, is a Unix shell and command language
      that provides an interactive command-line environment as well as
      facilities for scripting system operations, process control, and
      program execution. It is widely used as the default shell on many
      Unix-like systems and serves as a primary interface for automating
      tasks and composing pipelines of commands.
    links: {Reference: https://www.gnu.org/software/bash/manual/, Repository: https://git.savannah.gnu.org/cgit/bash.git}
    source:
      Ext: [.bash]
      She: [bash]
      Files: [.bash_login, .bash_logout, .bash_profile, .bashrc]
      Like: Shell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  batchfile:
    aka: [Batch]
    description: |-
      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.
    links: {Reference: https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/windows-commands}
    source:
      Ext: [.bat, .btm, .cmd]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[REM, "\n"], [rem, "\n"], ["::", "\n"]]
  bc:
    aka: ['basic calculator']
    description: |-
      bc is an arbitrary-precision calculator language traditionally found
      on Unix systems. It provides interactive and scriptable numeric
      computation with variables, arrays, functions, control flow, and
      configurable numeric scale, making it useful both as a command-line
      calculator and as a small language for portable calculation scripts.
    links: {Reference: https://www.gnu.org/software/bc/manual/html_mono/bc.html}
    source:
      Ext: [.bc]
      She: [bc]
      Bc: [[/*, '*/'], ['#', "\n"]]
      Str: [['"', '"', bse]]
      St: ;
      Co: ['if ', 'while ', 'for ', 'define ', '&& ', '|| ', '!= ', '== ', '<= ', '>= ', '< ', '> ']
  BBCSDL:
    description: |-
      BBCSDL is a modern open-source implementation of the venerable BBC BASIC
      language for microcomputers that uses the portable SDL library for graphics
      and runs under Linux, Windows, macOS, Raspberry Pi, Android, and iOS.
    links: {Repository: https://github.com/rtrussell/BBCSDL}
    source:
      Ext: [.bbc]
      Like: 'BASIC'
  Beancount:
    aka: [Bean]
    description: |-
      Beancount is a plain-text double-entry accounting language used by the
      Beancount bookkeeping tools.
    links: {Reference: https://beancount.github.io/docs/beancount_language_syntax/, Repository: https://github.com/beancount/beancount}
    source:
      Ext: [.beancount]
      Bc: [[;, "\n"]]
      Str: [['"', '"', bse]]
      Co: ['open ', 'close ', 'commodity ', 'balance ', 'pad ', 'event ', 'query ', 'custom ', 'price ', 'note ', 'document ', 'option ', 'plugin ', 'include ', 'txn ']
      Fl: xdsl
  BeanShell:
    description: |-
      BeanShell is an interpreted scripting language for the Java platform
      that allows Java syntax to be executed dynamically without a separate
      compilation step.  Scripts run inside the Java Virtual Machine and can
      directly create objects, call methods, and access classes from the
      standard library or from application code available on the class path.
    links: {Website: https://beanshell.github.io/}
    source:
      Ext: [.bsh, .bean]
      Like: C-like
  Beeflang:
    aka: [Beef]
    description: |-
      Beeflang (often written just "Beef") is an open-source, 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.
    links: {Website: https://www.beeflang.org/}
    source:
      Ext: [.bf]
      Like: C-like
      St: ;
      Fl: xcpp
  Beluga:
    description: |-
      Beluga is a configuration-style language used to describe structured
      data and settings through named sections and key-value assignments. It
      is designed for readability and organization, enabling systems to load
      and interpret configuration state in a predictable and declarative
      manner.
    links: {Reference: https://beluga-lang.org/, Repository: https://github.com/BelugaLang}
    source:
      Ext: [.bel]
      Str: [['"', '"', ml]]
      Fl: xcfg
      Bc: [['#', "\n"]]
  BibTeX:
    description: |-
      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.
    links: {Website: https://www.bibtex.org/}
    source:
      Ext: [.bib]
      Fl: xdsl
      Bc: [['%', "\n"]]
  Bicep:
    description: |-
      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.
    links: {Reference: https://learn.microsoft.com/azure/azure-resource-manager/bicep/}
    source:
      Ext: [.bicep]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [["'''", "'''", ml], ["'", "'", bse]]
      Co: ['@minLength(', '@maxLength(', '@secure(', '[for ', if(, if (, ' == ', ' != ', ' ? ', 'using ', range(, 'type ', 'func ']
      Fl: xcfg
  BitBake:
    description: |-
      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.
    links: {Reference: https://docs.yoctoproject.org/bitbake/}
    source:
      Ext: [.bb]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [['#', "\n"]]
  Blade:
    description: |-
      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.
    links: {Reference: https://laravel.com/docs/blade}
    source:
      Ext: [.blade.php]
      Bc: [['{{--', '--}}']]
      Co: ['@for ', '@for(', '@foreach ', '@foreach(', '@forelse ', '@forelse(', '@each ', '@each (', '@while ', '@while(', '@if ', '@if(', '@unless ', '@unless(', '@isset ', '@isset(', '@empty ', '@empty(', '@else ', '@elseif ', '@elseif(', '@while ', '@while(', '@switch ', '@switch (', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  BLISS:
    description: |-
      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.
    links: {Reference: https://bitsavers.org/pdf/dec/bliss/}
    source:
      Ext: [.bli]
      Fl: xdead
      Bc: [['!', "\n"]]
  Blueprint:
    description: |-
      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.
    links: {Reference: https://gitlab.gnome.org/jwestman/blueprint-compiler}
    source:
      Ext: [.blp]
      Str: [['"', '"', bse|ml], ['"""', '"""']]
      Fl: xmdl
      Bc: [[//, "\n"]]
  Boo:
    description: |-
      Boo is a statically typed, Python-like programming language for the
      Common Language Infrastructure that combines a concise syntax with
      metaprogramming facilities.
    links: {Website: https://boo-language.github.io, Repository: https://github.com/boo-lang/boo}
    source:
      Ext: [.boo]
      Like: Python-like
      Co: ['for ', 'if ', 'elif ', 'unless ', ' and ', 'for ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Bosque:
    description: |-
      Bosque is a research programming language developed by Microsoft
      Research that explores simplified semantics for large-scale software
      systems.  The design aims to eliminate categories of complex runtime
      behavior that make programs difficult to reason about, such as mutable
      shared state and unrestricted aliasing.
    links: {Reference: https://www.microsoft.com/en-us/research/project/bosque-programming-language/, Repository: https://github.com/microsoft/BosqueLanguage}
    source:
      Ext: [.bsq]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"']]
      Co: ['if ', if(, 'switch ', 'match ', 'case ', '| ', '|| ', '& ', '&& ', '!= ', '!== ', '== ', '=== ']
  BPMN:
    description: |-
      Business Process Model & Notation uses a standards-based modeling
      notation to define executable workflows and process logic for business
      automation. It is designed for use with workflow engines that
      interpret process definitions to coordinate tasks, events, and
      decision flows across systems and participants.
    links: {Reference: https://www.omg.org/bpmn/}
    source:
      Ext: [.bpmn, .bpmn20.xml]
      Like: XML-like
      Fl: xmdl
  BQN:
    description: |-
      BQN is a modern array programming language in the APL family. It uses
      dense symbolic notation and focuses on concise expression of array and
      matrix transformations.
    links: {Website: https://mlochbaum.github.io/BQN/, Reference: https://mlochbaum.github.io/BQN/doc/index.html, Repository: https://github.com/mlochbaum/BQN}
    source:
      Ext: ['.bqn']
      Bc: [['#', "\n"]]
      Str: [['"', '"'], ["'", "'"]]
  Bru:
    description: |-
      Bru is a human-readable request definition format used by the Bruno
      API client for storing and organizing HTTP requests as plain text
      files. A file describes the elements of a request such as the HTTP
      method, target URL, headers, parameters, authentication settings, and
      request body so that collections of requests can be versioned and
      edited outside a graphical interface.
    links: {Website: https://www.usebruno.com, Repository: https://github.com/usebruno/bruno}
    source:
      Ext: [.bru]
      Str: [['"', '"', bse|ml], ["'", "'", ml], ['"', '"', bse]]
      Fl: xcfg
      Bc: [['#', "\n"]]
  BSV:
    description: |-
      Bluespec SystemVerilog (BSV) is a high-level hardware description
      language for digital design. It uses a SystemVerilog-inspired surface
      syntax but differs semantically by expressing hardware behavior with
      guarded atomic rules, methods, interfaces, and strongly typed
      parameterized modules rather than conventional RTL process blocks.
      BSV is compiled into synthesizable Verilog and is used for FPGA and
      ASIC design, architecture exploration, and formally disciplined
      hardware development.
    links: {Website: https://github.com/B-Lang-org/bsc, Reference: https://gist.github.com/hanw/3667b17923579be6af0137b5b12b5243}
    source:
      Ext: [.bsv]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse]]
      St: ;
      Fl: xhdl
  BuildStream:
    description: |-
      BuildStream is a build orchestration and integration system designed
      for constructing complete software stacks in a deterministic and
      reproducible way. It models a project as a directed graph of build
      elements where each element describes how a component is obtained,
      built, and staged, and the system resolves dependencies and executes
      builds accordingly. The tool emphasizes strong isolation, artifact
      caching, and reproducibility so that identical inputs yield identical
      build outputs across different machines and environments. Projects
      define pipelines describing sources, build steps, and runtime
      composition, allowing large systems to be assembled from smaller
      components while maintaining clear dependency tracking.
    links: {Website: https://buildstream.build, Repository: https://github.com/apache/buildstream}
    source:
      Ext: [.bst]
      Like: YAML-like
      Fl: xcfg
  LPC:
    aka: ['Lars Pensjo C', LPMud LPC]
    description: |-
      LPC is a C-derived, object-oriented programming language used for
      implementing LPmud, MudOS, FluffOS, LDMud, and related MUD worlds.
      LPC source files define game objects with variables, functions,
      inheritance, efuns supplied by the driver, and datatypes such as
      strings, objects, mappings, arrays, and mixed values. It keeps much of
      C's expression and control-flow syntax while adding runtime-managed
      objects, garbage-collected values, prototype-style object loading, and
      driver-specific calls such as this_object(), this_player(), call_out(),
      clone_object(), move_object(), and add_action().
    links: {Reference: https://www.fluffos.info/concepts/general/lpc.html, Objects: https://www.ldmud.eu/lpc-objects.html, Inheritance: https://www.fluffos.info/lpc/constructs/inherit.html}
    source:
      Ext: [.c, .h]
      Like: C-like
      St: ;
      Fl: xcpp
      Require: ['^\s*inherit\s+|(?:\(\{|\(\[)|\b(?:mapping|mixed)\s+\*?\s*[A-Za-z_][A-Za-z0-9_]*\b|\b(?:nomask|nosave|simul_efun|efun)\b', '\b(?:create|reset|init|heart_beat)\s*\(|\b(?:this_object|this_player|previous_object|clone_object|destruct|add_action|set_short|set_long|move_object|tell_object|call_out|map_delete|allocate|keys|values)\s*\(|->\s*[A-Za-z_]']
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', 'inherit ', 'catch ', 'call_out', '&& ', '|| ', '!= ', '== ']
  C:
    description: |-
      C is a general-purpose systems programming language designed for
      efficient compilation and close interaction with hardware. Programs
      are organized as functions and global declarations, with execution
      beginning at main. The language provides primitive numeric types,
      pointers for direct memory manipulation, arrays and structures for
      aggregate data, and a preprocessor that performs textual inclusion and
      macro substitution before compilation. Control flow includes
      conditional statements, loops, and function calls, and most constructs
      are expression-oriented, allowing operations to be combined
      compactly. C is widely used for operating systems, embedded software,
      compilers, and performance-critical applications, and has strongly
      influenced many later programming languages.
    links: {Reference: https://www.cprogramming.com/reference/}
    source:
      Ext: [.c]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcpp
  Cassius:
    description: |-
      Cassius is a CSS templating language in the Shakespearean template
      family used by Yesod and related Haskell web libraries. It is a
      whitespace-sensitive alternative syntax for Lucius: indentation is
      used to delimit blocks instead of explicit braces and semicolons,
      while still supporting the same CSS-oriented interpolation features
      such as variable substitution and type-safe URL insertion.

      Cassius is primarily used to generate CSS at Haskell compile time as
      part of Yesod applications and other projects using the Shakespeare
      template toolkit.
    links: {Reference: https://www.yesodweb.com/book-1.4/shakespearean-templates, Package shakespeare: https://hackage.haskell.org/package/shakespeare, Package shakespeare-css: https://hackage.haskell.org/package/shakespeare-css}
    source:
      Ext: [.cassius]
      Like: CSS
      Fl: xtpl
  C Header:
    description: |-
      C headers are interface files used in C programs to declare functions,
      types, macros, constants, and external variables shared across
      multiple translation units. They are incorporated into source files
      through the C preprocessor include directive and serve as the primary
      mechanism for exposing library APIs and maintaining consistent
      declarations during compilation. Header files are widely used in both
      system libraries and application code to separate interface
      definitions from implementation.
    source:
      Ext: [.h]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'case ', 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: ign|xcpp
  C++:
    description: |-
      C++ is a general-purpose programming language that extends C with
      facilities for abstraction, generic programming, and object-oriented
      design while retaining the ability to write efficient low-level
      code. Programs are composed of functions, classes, templates, and
      namespaces, with compilation typically producing native machine
      code. The language supports encapsulation through classes, inheritance
      and virtual functions for polymorphism, and templates for
      type-parameterized algorithms and containers. Resource management is
      commonly expressed through constructors, destructors, and
      deterministic object lifetimes, enabling patterns such as RAII. The
      standard library provides containers, iterators, algorithms, and
      utilities that encourage reusable and type-safe programming across a
      wide range of domains including systems software, libraries, games,
      and performance-critical applications.
    links: {Reference: https://en.cppreference.com/w/cpp/language.html}
    source:
      Ext: [.cc, .cxx, .cpp]
      Like: C-like
      St: ;
      Str: [['R"([^\x00-\x20\x7f()\\]{0,16})\(', ')&"', ml|re]]
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcpp|eur
  C3:
    description: |-
      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.
    links: {Website: https://c3-lang.org/}
    source:
      Ext: [.c3, .c3i]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'switch ', switch(, 'case ', 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ', 'defer ', 'macro ']
  Cabal:
    description: |-
      Cabal files describe Haskell packages (metadata, dependencies, and
      build layout) for the Cabal build system.
    links: {Website: https://cabal.readthedocs.io/}
    source:
      Ext: [.cabal]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [[--, "\n"]]
  Cadence:
    description: |-
      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.
    links: {Website: https://docs.onflow.org/cadence/}
    source:
      Ext: [.cdc]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
      Fl: xctr
  Cairo:
    description: |-
      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.
    links: {Website: https://www.cairo-lang.org/}
    source:
      Ext: [.cairo]
      Str: [['"', '"', bse]]
      Co: ['loop ', 'if ', if(, 'match ', match(, 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[//, "\n"]]
      Fl: xctr
  Cake:
    description: |-
      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.
    links: {Website: https://cakebuild.net/}
    source:
      Ext: [.cake]
      Like: C-like
      St: ;
      Str: [['"', '"']]
      Fl: xbld
  Caddyfile:
    aka: [Caddy]
    description: |-
      Caddyfile is the human-oriented configuration language for the Caddy
      web server. Caddyfile documents define site blocks, global options,
      reusable snippets, request matching rules, named routes, and
      directives for static file service, reverse proxy service, TLS
      automation, logging, redirects, and other HTTP server behavior.
    links: {Reference: https://caddyserver.com/docs/caddyfile/concepts}
    source:
      Ext: [.caddyfile]
      Files: [Caddyfile]
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse], ['`', '`', ml]]
      Fl: xcfg
  Cangjie:
    description: |-
      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.
    links: {Reference: https://docs.cangjie-lang.cn/en/docs/1.0.0/user_manual/source_en/}
    source:
      Ext: [.cj]
      Like: C-like
      Co: ['for ', for(, 'if ', if(, 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Capnp:
    aka: ["Cap'n Proto"]
    description: |-
      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.
    links: {Website: https://capnproto.org/}
    source:
      Ext: [.capnp]
      Like: C-like
      St: ;
      Fl: xidl
  Carbon:
    description: |-
      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.
    links: {Reference: https://github.com/carbon-language/carbon-lang}
    source:
      Ext: [.carbon]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
  Carp:
    description: |-
      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.
    links: {Website: https://github.com/carp-lang/Carp}
    source:
      Ext: [.carp]
      Like: Lisp-like
  Ceylon:
    aka: ['Eclipse Ceylon']
    description: |-
      Ceylon was a statically typed object-oriented language for the JVM and
      JavaScript runtimes, designed with an emphasis on readability,
      modularity, null safety, and predictable semantics. The project was
      later moved to the Eclipse Foundation and is now inactive.
    links: {Introduction: https://en.wikipedia.org/wiki/Ceylon_(programming_language), Website: https://projects.eclipse.org/projects/technology.ceylon}
    source:
      Ext: [.ceylon]
      Bc: [['/*', '*/', cnest], ['//', "\n"], ['#!', "\n"]]
      Str: [['"""', '"""', ml], ['"', '"', ml, bse], ["'", "'", bse]]
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', '&& ', '|| ', '!= ', '== ']
      Fl: xdead
  CFDG:
    description: |-
      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.
    links: {Website: https://contextfreeart.org/}
    source:
      Ext: [.cfdg]
      Fl: xmdl
      Bc: [[//, "\n"]]
  Chapel:
    description: |-
      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.
    links: {Reference: https://chapel-lang.org/docs/}
    source:
      Ext: [.chpl]
      Like: C-like
      St: ;
      Str: [['"""', '"""', ml], ["'''", "'''", ml]]
      Co: ['for ', 'if ', 'switch ', 'while ', 'else ', 'do ', '|| ', '&& ', '!= ', '== ']
  ChucK:
    description: |-
      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.
    links: {Specification: http://chuck.cs.princeton.edu/doc/language/}
    source:
      Ext: [.ck]
      Bc: [[/*, '*/'], [//, "\n"]]
      St: ;
      Fl: xaud
  Circom:
    description: |-
      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.
    links: {Website: https://docs.circom.io/}
    source:
      Ext: [.circom]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', while(, 'else ', else(, '|| ', '&& ', '!= ', '== ']
      Fl: xctr
  Civet:
    description: |-
      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.
    links: {Website: https://civet.dev/, Repository: https://github.com/DanielXMoore/Civet}
    source:
      Ext: [.civet]
      Like: JavaScript-like
  Clarity:
    description: |-
      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.
    links: {Introduction: https://docs.stacks.co/write-smart-contracts/clarity-language, Reference: https://github.com/clarity-lang/reference}
    source:
      Ext: [.clar]
      Like: Lisp-like
      Fl: xctr
  CLIPS:
    description: |-
      CLIPS is a rule-based programming language and expert-system shell
      originally developed at NASA's Johnson Space Center. Programs define
      facts, templates, rules, functions, generic functions, classes, and
      instances that are evaluated by an inference engine, making CLIPS useful
      for knowledge-based systems where rules express heuristic behavior more
      directly than conventional algorithms.
    links: {Website: https://www.clipsrules.net/, Reference: https://clipsrules.net/documentation/v641/bpg641.pdf, Repository:  https://sourceforge.net/p/clipsrules/}
    source:
      Ext: [.clp]
      Bc: [[;, "\n"]]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Co: ['(defrule ', '(deffacts ', '(deftemplate ', '(deffunction ', '(defgeneric ', '(defmethod ', '(defclass ', '(definstances ', '(if ', '(while ', '(loop-for-count ', '(foreach ', '(and ', '(or ', '(not ', '(exists ', '(forall ']
  Clojure:
    description: |-
      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.
    links: {Reference: https://clojure.org/reference/reader}
    source:
      Ext: [.clj]
      Like: Lisp-like
      Co: ['(for ', '(when ', '(loop ', '(doseq ', '(cond ', (if, '(if-not ', '(and ', '(or ', '(not ', '(= ', '(not= ', '(recur ']
  Clean:
    description: |-
      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.
    links: {Website: https://clean.cs.ru.nl/}
    source:
      Ext: [.icl, .dcl]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse]]
  ClojureC:
    description: |-
      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
    links: {Reference: https://clojure.org/reference/reader}
    source:
      Ext: [.cljc]
      Like: Lisp-like
  ClojureScript:
    description: |-
      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.
    links: {Website: https://clojurescript.org/}
    source:
      Ext: [.cljs]
      Like: Lisp-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Closure Template:
    description: |-
      Closure Templates, also known as Soy, are a templating system
      developed at Google for generating HTML and other text formats with
      strong support for internationalization and safe output
      escaping. Templates are compiled to JavaScript and Java, allowing them
      to be rendered on either the client or server side with consistent
      behavior. The system enforces contextual autoescaping to prevent
      injection vulnerabilities and provides a structured template syntax
      with explicit parameters, control flow, and reusable components. It is
      widely used in large-scale web applications where security,
      localization, and maintainability are critical.
    links: {Website: https://developers.google.com/closure/templates, Repository: https://github.com/google/closure-templates}
    source:
      Ext: [.soy]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', '>= ', '<= ', '?: ', '? : ']
      Bc: [[/*, '*/'], [//, "\n"]]
      Fl: xtpl
  CloudFormation:
    description: |-
      CloudFormation is a declarative configuration language used for
      describing and provisioning infrastructure resources in Amazon Web
      Services. Templates define collections of cloud resources such as
      compute instances, networks, storage, and permissions along with the
      relationships and dependencies between them. The configuration
      expresses the desired state of the infrastructure, and the
      CloudFormation service creates or updates resources to match that
      description. Templates are commonly used to automate deployment,
      manage infrastructure changes in a controlled way, and maintain
      reproducible cloud environments.
    links: {Website: https://aws.amazon.com/cloudformation/, Introduction: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html, Repository: https://github.com/aws-cloudformation}
    source:
      Ext: [.template, .cfn]
      Like: YAML-like
      Co: ['!GetAtt', '!Sub', '!Select', '!Equals', '!If', 'DependsOn:', '!Select', '!Equals', '!If', 'Fn::If', 'Fn::And', 'Fn::Equals', 'Fn::Not', 'Fn::Or', 'Fn::Base64', 'Fn::Cidr', 'Fn::FindInMap', 'Fn::GetAtt', 'Fn::GetAZs', 'Fn::ImportValue', 'Fn::Join', 'Fn::Select', 'Fn::Split', 'Fn::Sub', 'Fn::Transform']
      Fl: xcfg
  CLU:
    description: |-
      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.
    links: {Reference: https://pmg.csail.mit.edu/CLU.html}
    source:
      Ext: [.clu]
      St: ;
      Str: [['"', '"']]
      Fl: xdead
      Bc: [['%', "\n"]]
  CMake:
    description: |-
      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.
    links: {Reference: https://cmake.org/cmake/help/latest/manual/cmake-language.7.html}
    source:
      Ext: [.cmake]
      Files: [cmakelists.txt]
      Bc: [['#[[', ']]'], ['#', "\n"]]
      Str: [['"', '"']]
      Co: ['foreach ', foreach(, 'if ', if(, 'elseif ', elseif(, 'while ', while(, 'else ', else(, 'OR ', 'AND ', 'EQUAL ', 'STREQUAL ', 'VERSION_EQUAL ', 'PATH_EQUAL ']
      Fl: xbld
  CML:
    description: |-
      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.
    links: {Website: https://www.cs.cornell.edu/Projects/cml/}
    source:
      Ext: [.cm]
      Like: Pascal-like
      St: ;
  COBOL:
    description: |-
      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.
    links: {Reference: https://www.iso.org/standard/74527.html}
    source:
      Ext: [.cob, .cbl]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['*', "\n"]]
  Cobra:
    description: |-
      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.
    links: {Website: https://cobra-language.com/}
    source:
      Ext: [.cobra]
      Bc: [[/#, '#/'], ['#', "\n"]]
      Str: [['"', '"', ml|bse]]
  CoCoA:
    aka: ["Computations in Commutative Algebra"]
    description: |-
      CoCoA 5 is the command and scripting language of the CoCoA
      computer algebra system; the project also supplies a C++
      library. It is used for symbolic algebra, polynomial ideals,
      Gröbner bases, and related computational mathematics tasks.
    links: {Website: https://cocoa.altervista.org/cocoalib/index.shtml}
    source:
      Ext: ['.c5', '.cocoa5', '.cpkg5', '.cocoa5server']
      Fl: ['xmat']
  CodeQL:
    description: |-
      CodeQL is a query language used for analyzing source code by
      representing programs as relational databases and expressing queries
      over those structures. Queries describe patterns in code such as data
      flows, control flows, and structural relationships between program
      elements, enabling developers and security researchers to detect bugs,
      vulnerabilities, and other properties of software systems. CodeQL
      queries are written in a declarative style resembling logic and
      relational query languages and are executed against databases
      generated from the analyzed source code. The language and associated
      tooling are widely used for automated code analysis and security
      scanning.
    links: {Website: https://codeql.github.com, Repository: https://github.com/github/codeql}
    source:
      Ext: [.ql, .qll]
      Like: C-like
      Str: [['"', '"', bse]]
      Fl: xqry
      Co: ['and ', 'or ', 'implies ', 'if ', 'else ', 'not ', 'instanceof ', 'in ', exists(, 'forall( ', avg(, concat(, count(, max(, min(, rank(, strictconcat(, strictcount(, strictsum(, sum(]
  CoffeeScript:
    description: |-
      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.
    links: {Language reference: https://coffeescript.org/#language}
    source:
      Ext: [.coffee]
      Bc: [['###', '###', cnest], ['#', "\n"]]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", ml], ['"', '"', ml|bse], ["'", "'", ml]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Cogent:
    description: |-
      Cogent is a systems language with an affine type discipline, designed
      for verification-oriented low-level software.
    links: {Website: https://cogent.readthedocs.io/}
    source:
      Ext: [.cogent]
      Like: Haskell-like
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  COMAL:
    description: |-
      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.
    links: {Reference: https://en.wikipedia.org/wiki/COMAL}
    source:
      Ext: [.cml]
      Str: [['"', '"']]
      Fl: xdead
      Bc: [[REM, "\n"]]
  CORBA IDL:
    aka: ['OMG IDL']
    description: |-
      CORBA IDL (Common Object Request Broker Architecture Interface
      Definition Language) is the interface definition language standardized
      by the Object Management Group for describing distributed-object
      interfaces, data types, exceptions, and modules in CORBA systems.
      CORBA IDL specifications are language-neutral contracts that can be
      compiled into bindings for languages such as C++, Java, and Ada.
    links: {Reference: https://www.omg.org/spec/IDL/}
    source:
      Ext: [.idl]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  ConstraintGrammar:
    description: |-
      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.
    links: {Reference: https://visl.sdu.dk/cg3.html}
    source:
      Ext: [.cg, .cg3]
      St: ;
      Fl: xdsl
      Bc: [['!', "\n"]]
  CORC:
    description: |-
      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.
    links: {Website: https://gitlab.com/esr/cupl}
    source:
      Ext: [.corc]
      Fl: xdead
      Bc: [[COMMENT, "\n", sol]]
  CppModule:
    description: |-
      CppModule refers to C++ source files that define module interface or
      module implementation units using the C++20 modules system.  C++ modules
      provide a modern mechanism for organizing and importing program
      interfaces, replacing many traditional uses of header files and the
      preprocessor.
    links: {Reference: https://en.cppreference.com/w/cpp/language/modules}
    source:
      Ext: [.cppm, .ixx, .ccm, .mpp, .mxx, .cxxm, .hppm, .hxxm, .c++m, .cpmm]
      Like: C++
  Creole:
    description: |-
      Creole is a lightweight wiki markup language designed to provide a
      common and simple syntax for editing wiki pages across different wiki
      engines. Documents use straightforward textual conventions to
      represent formatting elements such as headings, lists, links,
      emphasis, and literal formatted blocks so that authors can write structured
      content without using HTML. The language was created as part of the
      WikiCreole initiative to reduce incompatibilities among existing wiki
      syntaxes and to encourage portability of wiki content between systems.
    links: {Website: https://wikicreole.org/}
    source:
      Ext: [.creole]
      Bc: [['{{{', '}}}']]
      Fl: xcfg
  Crystal:
    description: |-
      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.
    links: {Language reference: https://crystal-lang.org/reference/}
    source:
      Ext: [.cr]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
  csh:
    aka: ['C Shell']
    description: |-
      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.
    links: {Reference: https://docs.oracle.com/cd/E19253-01/816-5165/csh-1/index.html}
    source:
      Ext: [.csh]
      Files: [.cshrc, .tcshrc, .login]
      She: [csh, tcsh]
      Str: [['"', '"'], ["'", "'"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
  CSON:
    description: |-
      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.
    links: {Repository: https://github.com/bevry/cson}
    source:
      Ext: [.cson]
      Str: [['"', '"', bse]]
      Fl: xser
      Bc: [['#', "\n"]]
  Csound:
    description: |-
      Csound is a sound and music programming language for audio synthesis,
      signal processing, algorithmic composition, and real-time or offline
      rendering. Programs commonly combine an orchestra, which defines
      instruments and signal-processing graphs, with a score that schedules
      events, function tables, and other performance data. The unified .csd
      format stores options, orchestra code, score data, and optional
      embedded resources in a structured text document, while traditional
      workflows may use separate orchestra and score files.
    links: {Website: https://csound.com/, Reference: https://csound.com/manual/, CSD Format: https://csound.com/manual/invoke/the-csd-file-format/}
    source:
      Ext: [.csd, .orc, .sco, .udo]
      Bc: [[/*, '*/'], [//, "\n"], [;, "\n"], ["<!--", "-->"]]
      Str: [['"', '"', bse]]
      Co: ['instr ', 'endin', 'opcode ', 'endop', 'if ', ' then', 'elseif ', 'else', 'endif', 'while ', 'od', 'until ', 'goto ', 'kgoto ', 'igoto ', 'loop_lt ', 'loop_le ', 'loop_gt ', 'loop_ge ', '<CsoundSynthesizer>', '<CsInstruments>', '<CsScore>']
      Fl: xaud
  CSS:
    description: |-
      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.
    links: {Website: https://www.w3.org/TR/css-syntax-3/}
    source:
      Ext: [.css]
      Bc: [[/*, '*/']]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
  CSV:
    description: |-
      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.
    links: {Reference: https://www.rfc-editor.org/rfc/rfc4180}
    source:
      Ext: [.csv]
      Fl: xser
  CUDA:
    description: |-
      CUDA (Compute Unified Device Architecture) is NVIDIA's GPU 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. Open-source implementations
      and toolchains, notably Clang, support compiling CUDA source.
    links: {Reference: https://llvm.org/docs/CompileCudaWithLLVM.html}
    source:
      Ext: [.cu, .cuh]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcpp
  CUE:
    description: |-
      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.
    links: {Website: https://cuelang.org/docs/}
    source:
      Ext: [.cue]
      Like: C-like
      Str: [['"', '"', bse], ["'", "'", bse], ["#(#{0,254})\"", "\"&#", re], ["#(#{0,254})'", "'&#", re], ['"""', '"""', ml|bse], ["'''", "'''", ml|bse], ["#(#{0,254})\"\"\"", "\"\"\"&#", ml|re], ["#(#{0,254})'''", "'''&#", ml|re]]
      Fl: xcfg
  CUPL:
    description: |-
      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.
    links: {Website: https://gitlab.com/esr/cupl}
    source:
      Ext: [.cupl]
      Fl: xdead
      Bc: [[COMMENT, "\n", sol]]
  Curry:
    description: |-
      Curry is a declarative multi-paradigm programming language that
      combines features of functional and logic programming. It supports
      non-deterministic computations, logic variables, and constraint
      solving, enabling programs that integrate pattern matching with
      goal-oriented evaluation.
    links: {Reference: https://www.curry-language.org/docs/, Repository: https://github.com/curry-language/curry2go}
    source:
      Ext: [.curry]
      Like: Haskell-like
  CWL:
    aka: ['Common Workflow Language']
    description: |-
      CWL is an open standard for describing command-line tools and
      portable computational workflows. CWL documents define inputs,
      outputs, execution requirements, hints, workflow steps, and references
      to command-line tools or nested workflows, typically using YAML syntax
      with a shared data model that can also be represented as JSON.
    links: {Website: https://www.commonwl.org/, Specification: https://www.commonwl.org/v1.2/}
    source:
      Ext: [.cwl]
      She: [cwl-runner]
      Like: YAML-like
      Fl: xdsl
  Cypher:
    description: |-
      Cypher is a declarative query language for property graph databases
      originally developed for the Neo4j database system. It allows users to
      express graph pattern matching queries using a syntax that describes
      nodes, relationships, and traversal patterns directly in the
      query. Cypher is used to retrieve, create, update, and delete graph
      data and has influenced the design of graph query standards such as
      GQL.
    links: {Reference: https://neo4j.com/developer/cypher/}
    source:
      Ext: [.cyp, .cypher]
      Bc: [[/*, '*/'], [--, "\n"]]
      Co: [MATCH, OPTIONAL MATCH, WHERE, UNION, CALL, UNWIND, STARTS WITH, ENDS WITH, CONTAINS, shortestPath, allShortestPaths, '-[*..]->']
      Fl: xqry
  Cython:
    description: |-
      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.
    links: {Website: https://cython.readthedocs.io/}
    source:
      Ext: [.pyx, .pxd, .pxi]
      Like: Python-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', 'and ', 'or ', 'not ', 'in ']
  D2:
    description: |-
      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.
    links: {Introduction: https://d2lang.com/tour/intro/}
    source:
      Ext: [.d2]
      Str: [['"', '"']]
      Fl: xmdl
      Bc: [['#', "\n"]]
  DAML:
    description: |-
      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.
    links: {Website: https://docs.daml.com/}
    source:
      Ext: [.daml]
      Like: Haskell-like
      Str: [['"', '"']]
      Co: ['if ', 'then ', 'else ', '|| ', '&& ', '/= ', '== ', 'case ', 'do {', 'forall ']
      Fl: xctr
  Dafny:
    description: |-
      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.
    links: {Website: https://dafny.org/}
    source:
      Ext: [.dfy]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
  Dart:
    description: |-
      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.
    links: {Website: https://dart.dev/language}
    source:
      Ext: [.dart]
      St: ;
      Str: [['"""', '"""', bse|ml], ['"', '"', bse], ["'", "'"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[//, "\n"]]
  DebianControl:
    description: |-
      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.
    links: {Reference: https://www.debian.org/doc/debian-policy/ch-controlfields.html}
    source:
      Files: [control]
      Fl: xbld
      Bc: [['#', "\n"]]
  Derw:
    description: |-
      Derw is a general-purpose, statically typed functional programming
      language in the ML family. It is inspired by Elm and Haskell and is
      designed to compile to TypeScript and JavaScript for client-side and
      server-side applications on the JavaScript platform.
    links: {Reference: https://docs.derw-lang.com/derw.md, Repository: https://github.com/eeue56/derw, Package: https://www.npmjs.com/package/derw}
    source:
      Ext: [.derw]
      Like: Haskell-like
      Str: [['`', '`', bse|ml]]
      Co: ['if ', 'case ', 'else ', '|| ', '&& ', '!= ', '== ']
  Dhall:
    description: |-
      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.
    links: {Website: https://dhall-lang.org/}
    source:
      Ext: [.dhall]
      Bc: [['{-', '-}', cnest], [--, "\n"]]
      Str: [["''", "''", ml], ['"', '"', bse]]
      Fl: xcfg
  diff:
    description: |-
      diff is the unified or context patch format used to describe textual
      differences between file versions. It is a data interchange format for
      changes rather than a programming language.
    links: {Reference: https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html}
    source:
      Ext: [.diff]
      Fl: xdsl
  DITA:
    description: |-
      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.
    links: {Website: https://www.oasis-open.org/committees/dita}
    source:
      Ext: [.dita, .ditamap]
      Like: XML-like
      Fl: doc|xdsl
  Djot:
    description: |-
      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.
    links: {Website: https://djot.net/}
    source:
      Ext: [.dj, .djot]
      Fl: doc
  Der:
    description: |-
      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.
    links: {Repository: https://github.com/vnmakarov/der}
    source:
      Ext: [.der]
      Like: C-like
      St: ;
      Str: [['"', '"']]
      Fl: xcpp|xdsl
  DesktopFile:
    description: |-
      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.
    links: {Reference: https://specifications.freedesktop.org/desktop-entry-spec/latest/}
    source:
      Ext: [.desktop]
      Fl: xcfg
      Bc: [['#', "\n"]]
  DeviceTree:
    aka: ['Device Tree']
    description: |-
      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.
    links: {Website: https://devicetree-specification.readthedocs.io/}
    source:
      Ext: [.dts, .dtsi]
      Like: C-like
      St: ;
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xhdl
  Dockerfile:
    description: |-
      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.
    links: {Reference: https://docs.docker.com/engine/reference/builder/}
    source:
      Ext: [.dockerfile]
      Files: [dockerfile, Containerfile]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [['#', "\n"]]
  DockerIgnore:
    description: |-
      Docker Ignore files define exclusion patterns that control which files
      and directories are omitted from the build context sent to the Docker
      daemon. The syntax is similar to other ignore-file formats, using
      glob-style pattern matching, directory rules, and negation to
      fine-tune inclusion. These files help reduce build time, improve
      caching behavior, and avoid unintentionally including sensitive or
      unnecessary content in container images. They are evaluated relative
      to the build context root and processed in order, with later rules
      overriding earlier ones.
    links: {Introduction: https://docs.docker.com/build/building/context/#dockerignore-files}
    source:
      Files: [.dockerignore]
      Fl: xcfg
      Bc: [['#', "\n"]]
  Dotenv:
    aka: [dotenv, '.env']
    description: |-
      Dotenv files are plain-text configuration files that load environment
      variables into a process. They store key-value assignments such as
      NAME=value, optionally using quoted values, export prefixes, comments,
      and environment-specific files such as .env.local or .env.production.
      They originated in the Ruby ecosystem via the Dotenv library but are
      now used across a wide range of languages and frameworks, including
      Node.js applications, Python applications, Ruby on Rails, Django, Flask,
      Docker Compose, and many others.
    links: {Reference: https://github.com/motdotla/dotenv}
    source:
      Ext: [.env, .env.local, .env.development, .env.production, .env.test, .env.staging, .env.example, .env.sample, .env.dist, .env.template]
      Files: [.env, .env.local, .env.development, .env.production, .env.test, .env.staging, .env.example, .env.sample, .env.dist, .env.template]
      Bc: [['#', "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", bse], ['`', '`', bse]]
      Fl: xcfg
  DM:
    description: |-
      DM (Dream Maker) is the programming language used by the BYOND
      platform for creating networked multiplayer games.  The language
      includes constructs for event handling, object spawning, and
      interaction with the BYOND runtime environment.
    links: {Website: https://www.byond.com/, Reference: https://www.byond.com/docs/ref/, Repository: https://github.com/OpenDreamProject/OpenDream}
    source:
      Ext: [.dm]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', '||', '&&', '!=', <>, ==, 'in ']
  DOT:
    description: |-
      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.
    links: {Reference: https://graphviz.org/doc/info/lang.html}
    source:
      Ext: [.dot, .gv]
      Like: C-like
      Str: [['"', '"']]
      Fl: xmdl
  Drools:
    description: |-
      Drools Rule Language is a domain-specific language used by the Drools
      rule engine to define business rules, facts, and inference logic in
      production systems. It expresses rules in a declarative form using
      condition–action pairs that are evaluated by a forward-chaining engine
      based on the Rete algorithm.
    links: {Reference: https://docs.drools.org/latest/drools-docs/html_single/#_drl_rules, Repository: https://github.com/kiegroup/drools}
    source:
      Ext: [.drl]
      Like: C-like
      Fl: xdsl
  DTD:
    description: |-
      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.
    links: {Reference: https://www.w3.org/TR/xml/#sec-prolog-dtd}
    source:
      Ext: [.dtd]
      Bc: [["<!--", "-->"]]
      Fl: xdsl
  Dune:
    description: |-
      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.
    links: {Website: https://dune.build/}
    source:
      Ext: [.dune]
      Fl: xbld
      Bc: [[;, "\n"]]
  Dust:
    description: |-
      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.
    links: {Reference: https://github.com/linkedin/dustjs/wiki/Syntax-Reference}
    source:
      Ext: [.dust, .dustjs]
      Bc: [['{!', '!}']]
      Fl: xtpl
  Dylan:
    description: |-
      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.
    links: {Reference manual: https://opendylan.org/books/drm/}
    source:
      Ext: [.dylan]
      Bc: [[/*, '*/'], [//, "\n"]]
      St: ;
  Earthfile:
    description: |-
      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.
    links: {Website: https://earthly.dev/}
    source:
      Files: [Earthfile]
      Fl: xbld
      Bc: [['#', "\n"]]
  ECPP:
    description: |-
      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.
    links: {Website: https://tntnet.org/}
    source:
      Ext: [.ecpp]
      Bc: [[<%--, --%>]]
      Str: [[<%, '%>', ml]]
      Fl: xtpl
  Eclipse Builder Configuration:
    description: |-
      A workspace-level configuration format used by Eclipse-based
      environments to define project-specific build steps, including
      external tools and plugin-provided builders. These files are typically
      generated and maintained by the IDE and its extensions rather than
      edited directly.
    links: {Reference: https://help.eclipse.org/latest/topic/org.eclipse.platform.doc.isv/reference/extension-points/org_eclipse_core_resources_builders.html, Repository: https://github.com/eclipse-platform/eclipse.platform.resources}
    source:
      Ext: [.builder.xml]
      Like: XML-like
      Fl: xbld
  EDN:
    description: |-
      EDN (Extensible Data Notation) is a Clojure-family data DSL for
      structured literals and configuration-like data exchange.
    links: {Repository: https://github.com/edn-format/edn}
    source:
      Ext: [.edn]
      Str: [['"', '"', bse]]
      Fl: xser
      Bc: [[;, "\n"]]
  ebuild:
    description: |-
      ebuild is Gentoo's package-build DSL, implemented as constrained
      shell-style scripts with package-manager conventions.
    links: {Reference: https://devmanual.gentoo.org/ebuild-writing/}
    source:
      Ext: [.ebuild]
      Str: [['"', '"', ml|bse]]
      Fl: xbld
      Bc: [['#', "\n"]]
  EditorConfig:
    description: |-
      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.
    links: {Website: https://editorconfig.org/}
    source:
      Files: [.editorconfig]
      Fl: xcfg
      Bc: [['#', "\n"]]
  EdgeQL:
    description: |-
      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.
    links: {Reference: https://www.edgedb.com/docs/reference/edgeql}
    source:
      Ext: [.edgeql]
      Str: [["'", "'", ml], ['"', '"', bse|ml], ['"', '"', bse]]
      Fl: xqry
      Bc: [['#', "\n"]]
  EJS:
    description: |-
      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.
    links: {Website: https://ejs.co/}
    source:
      Ext: [.ejs]
      Str: [[<%, '%>', ml], ['"', '"']]
      Fl: xtpl
      Bc: [[<%#, "\n"]]
  elisp:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/emacs/manual/html_mono/elisp.html}
    source:
      Ext: [.el]
      Like: Lisp-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Elm:
    description: |-
      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.
    links: {Website: https://elm-lang.org/docs}
    source:
      Ext: [.elm]
      Like: Haskell-like
      Str: [['"""', '"""', ml]]
      Co: ['for ', for(, 'if ', if(, 'case ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Elvish:
    description: |-
      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.
    links: {Reference: https://elv.sh/ref/language.html}
    source:
      Ext: [.elv]
      Like: Shell-like
  EmacsDevEnv:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/emacs/manual/html_node/ede/}
    source:
      Ext: [.ede]
      Like: Lisp-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
  Embedded Crystal:
    description: |-
      Embedded Crystal is a templating format used by the Crystal
      programming language to embed executable Crystal code within text
      documents, typically for generating HTML output. It is processed by
      the Crystal toolchain to produce dynamic content by interleaving
      static markup with evaluated code.
    links: {Reference: https://crystal-lang.org/reference/syntax_and_semantics/embedded_crystal.html, Repository: https://github.com/crystal-lang/crystal}
    source:
      Ext: [.ecr]
      Like: XML-like
      Fl: xtpl
  ERB:
    aka: ['Ruby HTML']
    description: |-
      ERB templates (often called RubyHTML) is a templating format used in
      Ruby web frameworks to embed Ruby code inside HTML documents.
    links: {Reference: https://ruby-doc.org/stdlib/libdoc/erb/}
    source:
      Ext: [.rhtml, .erb]
      Bc: [[<%#, '%>']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  Erlang:
    description: |-
      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.
    links: {Reference: https://www.erlang.org/doc/reference_manual/introduction.html}
    source:
      Ext: [.erl, .hrl]
      She: [escript]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: erlang
      Bc: [['%', "\n"]]
  es6:
    description: |-
      ECMAScript 6, also known as ECMAScript 2015, is a major revision of
      the ECMAScript language specification that standardized many modern
      language features for JavaScript. The revision introduced modules,
      classes, arrow functions, lexical bindings, enhanced object and array
      literals, destructuring, promises, iterators, and generators. These
      additions significantly expanded the expressive power of the language
      and formed the basis of modern JavaScript development across browsers
      and server-side runtimes.
    links: {Introduction: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import, Reference: https://www.ecma-international.org/ecma-262/9.0/}
    source:
      Ext: [.mjs, .es6, .es6.js]
      Like: JavaScript-like
  ESDL:
    description: |-
      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.
    links: {Website: https://energytransition.github.io/}
    source:
      Ext: [.esdl]
      Str: [['"', '"']]
      Fl: xdsl
      Bc: [['#', "\n"]]
  F*:
    description: |-
      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.
    links: {Website: https://fstar-lang.org/}
    source:
      Ext: [.fst]
      Bc: [[(*, '*)', cnest]]
      Sb: begin
      Eb: end
      Str: [['"', '"', bse], ["'", "'"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  FAUST:
    aka: ['Functional Audio Stream']
    description: |-
      FAUST is a functional, block-diagram-oriented programming language for
      real-time audio signal processing, synthesis, effects, and musical
      instrument design. A FAUST program describes a DSP signal processor as
      a collection of metadata declarations, imports, definitions, and
      expressions, with a required process definition acting as the main
      signal graph. The compiler translates FAUST source into a range of
      host languages and plugin or application targets, allowing one DSP
      specification to be deployed across many audio environments.
    links: {Website: https://faust.grame.fr/, Reference: https://faustdoc.grame.fr/manual/syntax/, Libraries: https://faustlibraries.grame.fr/}
    base:
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse]]
      St: ;
      Co: ['process ', 'process=', 'import(', 'component(', 'library(', 'declare ', 'with {', 'letrec {', 'environment {', 'case {', '=>', 'par(', 'seq(', 'sum(', 'prod(', 'select2(', 'select3(', 'button(', 'checkbox(', 'hslider(', 'vslider(', 'nentry(', '&& ', '|| ', '!= ', '== ', '<: ', ':> ', ': ', '~ ']
      Fl: xaud
    variants:
      DSP source:
        Ext: [.dsp]
      library source:
        Ext: [.lib]
        #Require: ['^\s*(?:declare\s+(?:[A-Za-z_][A-Za-z0-9_]*\s+)?[A-Za-z_][A-Za-z0-9_]*\s+"|[A-Za-z_][A-Za-z0-9_]*\s*=\s*(?:library|component)\s*\(\s*"[^"]+\.(?:lib|dsp)"|(?:import|component|library)\s*\(\s*"[^"]+\.(?:lib|dsp)")', '^\s*[A-Za-z_][A-Za-z0-9_]*(?:\s*\([^)]*\))?\s*=|<:|:>|=>|\b(?:with|environment|letrec|case)\s*\{|\b(?:par|seq|sum|prod|select2|select3|button|checkbox|hslider|vslider|nentry)\s*\(']
  Factor:
    description: |-
      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.
    links: {Factor handbook: https://docs.factorcode.org/content/article-handbook.html}
    source:
      Ext: [.factor]
      Str: [['"', '"', ml|bse], ["'", "'", ml]]
      Co: [if, when, unless, 'if*', 'when*', 'unless*', '?if', '?', cond, case, cond>quot, case>quot, alist>quot, while, until, loop, '0&&', '1&&', '2&&', '3&&', 'n&&', '&&', '0||', '1||', '2||', '3||', 'n||', '||', and, or, xor, eq, '=', smart-if, 'smart-if*', smart-when, 'smart-when*', smart-unless, smart-unless*]
      Bc: [['!', "\n"]]
  Fantom:
    description: |-
      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.
    links: {Reference: https://fantom.org/doc/docLang/index}
    source:
      Ext: [.fan]
      Like: C-like
      Str: [[<|, '|>', ml], ["'''", "'''", ml]]
  Fennel:
    description: |-
      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.
    links: {Website: https://fennel-lang.org/}
    source:
      Ext: [.fnl]
      Like: Lisp-like
      Str: [['"', '"', ml|bse]]
      Co: [(for, (each, (if, (when, (while, (switch, (do, (.., (=, (and, (or]
      Bc: [[;, "\n"]]
  FIDL:
    description: |-
      FIDL is the interface definition language used by the Fuchsia operating
      system to describe protocols and data types exchanged between system
      components.  A FIDL specification defines messages, structures, unions,
      and interfaces that participating programs use to communicate through
      the platform's inter-process communication mechanisms.
    links: {Reference: https://fuchsia.dev/fuchsia-src/reference/fidl, Repository: https://github.com/google/fuchsia/tree/main/tools/fidl}
    source:
      Ext: [.fidl]
      Bc: [[//, "\n"]]
      Str: [['"', '"', bse]]
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  FIRRTL:
    aka: ['Flexible Intermediate Representation for RTL']
    description: |-
      FIRRTL is a hardware intermediate representation and compiler language
      used by Chisel and related digital circuit tools. FIRRTL files describe
      circuits, modules, external modules, ports, wires, registers, memories,
      instances, nodes, connections, conditional statements, primitive
      operations, and source information annotations before translation to
      Verilog or other hardware back ends.
    links: {Project: https://bar.eecs.berkeley.edu/projects/firrtl.html, Specification: https://www2.eecs.berkeley.edu/Pubs/TechRpts/2016/EECS-2016-9.pdf, Repository: https://github.com/chipsalliance/firrtl}
    source:
      Ext: [.fir]
      Bc: [[;, "\n"]]
      Str: [['"', '"', bse]]
      Co: ['module ', 'extmodule ', 'input ', 'output ', 'wire ', 'reg ', 'mem ', 'inst ', 'node ', 'when ', 'else ', skip, 'is invalid', '<= ', '<- ', '=> ', 'mux(', 'validif(', 'printf(', 'stop(']
      Fl: xhdl
  fish:
    description: |-
      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.
    links: {Reference: https://fishshell.com/docs/current/}
    source:
      Ext: [.fish]
      She: [fish]
      Like: Shell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  FlatBuffers:
    description: |-
      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.
    links: {Reference: https://flatbuffers.dev/schema/}
    source:
      Ext: [.fbs]
      Like: C-like
      St: ;
      Fl: xidl
  Flow9:
    description: |-
      Flow9 is a statically typed functional programming language developed as
      part of the Flow programming platform.  Programs are written as modules
      containing type definitions, value declarations, and functions that
      operate on immutable data structures.  The language emphasizes pure
      functional programming with algebraic-style data types and pattern
      matching as primary mechanisms for structuring programs.
    links: {Repository: https://github.com/area9innovation/flow9}
    source:
      Ext: [.flow]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"']]
      Co: ['if ', if(, 'else ', 'else{', 'fori ', fori(, 'switch ', switch(, 'fold ', fold(, '|| ', '&& ', '!= ', '== ', '|> ']
  FOCAL:
    description: |-
      FOCAL is a interactive language designed for conversational use on
      early minicomputers, especially in educational and scientific
      settings. It was widely associated with DEC systems such as the PDP
      series and saw use in instructional computing as well as specialized
      applications, including adaptations for spaceflight. It is extinct
      in production, though open-source interpreters exist.
    links: {Introduction: https://en.wikipedia.org/wiki/FOCAL_(programming_language), Reference: https://bitsavers.org/pdf/dec/pdp8/focal/DEC-08-AJAB-D_FOCAL_Programming_Manual_Jan70.pdf}
    source:
      Ext: [.foc]
      St: ;
      Str: [['"', '"']]
      Fl: num|xdead
      Bc: [[C, "\n"]]
  Fortran90:
    aka: ['Fortran Modern', 'FORTRAN Modern']
    description: |-
      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.
    links: {Reference: https://j3-fortran.org/doc/year/18/18-007r1.pdf}
    source:
      Ext: [.f03, .f08, .f90, .f95]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: f90
  FTL:
    aka: FreeMarker
    description: |-
      FreeMarker Template Language (FTL) is a template DSL for generating
      text (often HTML) from data models in JVM-based applications.
    links: {Reference: https://freemarker.apache.org/docs/index.html}
    source:
      Ext: [.ftl, .ftlh, .ftlx]
      Bc: [[<#--, "-->"]]
      Co: ['<#list ', '<#assign ', '<#if ', '<#elseif ', <#else>, '<#else> ', '<#switch  ', '<#case ', <#default>, '<#default> ', '!= ', '== ']
      Fl: xtpl
  Frege:
    description: |-
      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.
    links: {Repository: https://github.com/Frege/frege}
    source:
      Ext: [.fr]
      Bc: [['{-', '-}', cnest], [--, "\n"]]
  FSL:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/Finite-state_machine}
    source:
      Ext: [.fsl]
      Co: [->, <-]
      Fl: xdsl
  Futhark:
    description: |-
      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.
    links: {Reference: https://futhark.readthedocs.io/en/stable/language-reference.html}
    source:
      Ext: [.fut]
      Str: [['"', '"']]
      Co: ['if ', 'else ', 'then ', 'for ', 'loop ', 'while ', '|| ', '&& ', '!= ', '>= ', '<= ']
      Bc: [[--, "\n"]]
  FXML:
    description: |-
      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.
    links: {Reference: https://openjfx.io/javadoc/21/javafx.fxml/javafx/fxml/doc-files/introduction_to_fxml.html}
    source:
      Ext: [.fxml]
      Like: XML-like
      Fl: xidl
  Gambas:
    description: |-
      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.
    links: {Website: https://gambas.sourceforge.net/}
    source:
      Ext: [.gbs, .gbi]
      Like: VBA-like
  Game Maker Project:
    description: |-
      GameMaker Project is a JSON-based project file format used by the
      GameMaker development environment to describe the structure of a game
      project. It defines resources such as objects, rooms, scripts,
      sprites, and their organization within the project, along with
      references to associated files. The project file is used by the
      GameMaker IDE to load, manage, and build games.
    links: {Website: https://manual.yoyogames.com/, Repository: https://github.com/YoYoGames/GameMaker-Manual}
    source:
      Ext: [.yyp]
      Like: JSON-like
      Fl: xbld
  GAP:
    description: |-
      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.
    links: {Website: https://www.gap-system.org/}
    source:
      Ext: [.g]
      St: ;
      Str: [['"', '"', bse]]
      Fl: xmat
      Bc: [['#', "\n"]]
  GDB:
    description: |-
      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".
    links: {Reference: https://sourceware.org/gdb/current/onlinedocs/gdb/}
    source:
      Ext: [.gdb, .gdbinit]
      Files: [gdbinit]
      Fl: xcfg
      Bc: [['#', "\n"]]
  GDScript:
    description: |-
      GDScript is a high-level scripting language used with the open-source
      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.
    links: {Reference: https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/}
    source:
      Ext: [.gd]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", bse|ml], ['"', '"', bse], ["'", "'", bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
  Gemfile:
    description: |-
      Gemfile is a Ruby-based configuration format used to declare and organize
      application dependencies for environments managed with Bundler. It expresses
      dependency sources, version constraints, grouping rules, and conditional
      loading logic in an executable DSL, allowing dependency resolution behavior to
      be shaped programmatically rather than purely declaratively.
    links: {Website: https://bundler.io/, Reference: https://bundler.io/man/gemfile.5.html, Repository: https://github.com/rubygems/bundler}
    source:
      Files: [gemfile]
      Like: Ruby-like
      Fl: xbld
  Gemtext:
    description: |-
      A lightweight markup format used in the Gemini protocol ecosystem to
      structure hypertext documents with a minimal and line-oriented syntax
      focused on readability and simplicity.
    links: {Reference: https://gemini.circumlunar.space/docs/gemtext.gmi}
    source:
      Ext: [.gmi]
      Fl: doc
  Gerber:
    aka: ['RS-274X', 'Extended Gerber', 'Gerber X2', 'Gerber X3']
    description: |-
      Gerber files are text command streams used to describe two-dimensional
      layer images for printed circuit board fabrication. A file defines
      units, coordinate format, aperture shapes, drawing and flash
      operations, regions, polarity, and optional attributes that identify
      layer function and manufacturing intent.
    links: {Specification: https://www.ucamco.com/files/downloads/file_en/554/gerber-layer-format-specification-revision-2026-05_en.pdf?eac6410808ad1d0b3f977429ddaab7d0=, File Formats: https://www.ucamco.com/en/file-formats}
    source:
      Ext: [.gbr]
      Bc: [[G04, '*']]
      St: '*'
      #Require: ['%(?:FSLA|MO(?:MM|IN)|ADD[0-9]+|TF\.FileFunction|LP[CD])|(?:^|\*)G0[123]\*|(?:^|\*)G3[67]\*|(?:^|\*)D0[123]\*|(?:^|\*)M02\*']
      Co: [G36, G37, D01, D02, D03, G01, G02, G03, '%AM', '%ADD', '%TF', '%TA', '%TO', '%TD', '%SR', '%LP']
      Fl: xhdl
  GenCat NLS:
    description: |-
      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.
    links: {Reference: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/gencat.html}
    source:
      Ext: [.msg]
      Fl: doc
  GitFastImport:
    description: |-
      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.
    links: {Reference: https://git-scm.com/docs/git-fast-import}
    source:
      Ext: [.fi, .fastimport]
      Fl: xser
  Gherkin:
    aka: [Cucumber]
    description: |-
      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.
    links: {Reference: https://cucumber.io/docs/gherkin/reference/}
    source:
      Ext: [.feature]
      Co: [given, when, then, and]
      Fl: doc|xtst
      Bc: [['#', "\n", sol]]
  Glade XML:
    description: |-
      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.
    links: {Website: https://developer.gnome.org/glade/}
    source:
      Ext: [.glade]
      Like: XML-like
      Fl: xmdl
  Gleam:
    description: |-
      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.
    links: {Website: https://gleam.run/docs/}
    source:
      Ext: [.gleam]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse]]
      Co: ['fn ', 'case ', '-> ', 'if ']
  GlossTeX:
    description: |-
      A macro-based extension for TeX and LaTeX used to define and manage
      glossaries and lists of terms, enabling automated generation and
      consistent formatting of terminology within structured documents.
    links: {Website: https://ctan.org/pkg/glosstex}
    source:
      Ext: [.glo, .gls]
      Fl: doc
      Bc: [['%', "\n"]]
  GLSL:
    description: |-
      GLSL is the OpenGL shading language for programmable graphics-pipeline
      stages.
    links: {Reference: https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf}
    source:
      Ext: [.glsl, .geom, .tesc, .tese, .comp]
      Like: C-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xshd
  Go:
    description: |-
      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.
    links: {Reference: https://go.dev/ref/spec}
    source:
      Ext: [.go]
      Like: C-like
      Str: [['`', '`', ml]]
      Co: ['go ', 'for ', for(, 'for{', 'if ', if(, 'switch ', switch(, 'switch{', 'select ', 'select{', 'else ', 'else{', '|| ', '&& ', '!= ', '== ']
  Go+:
    description: |-
      Go+ is a programming language developed as an extension of the Go
      language with a focus on improving usability for scripting, data
      processing, and education. It preserves compatibility with Go's core
      programming model while introducing conveniences such as simplified
      scripting syntax, native support for interactive and notebook-style
      workflows, and domain-oriented features aimed at beginners and data
      analysis tasks. Go+ programs can interoperate with Go libraries and
      are typically translated into Go for compilation and execution.
    links: {Website: https://goplus.org/, Repository: https://github.com/goplus/gop}
    source:
      Ext: [.gop]
      She: [gop]
      Like: Go
      Co: ['go ', 'for ', for(, 'if ', if(, 'switch ', 'select ', 'else ', '|| ', '&& ', '!= ', '== ', '?:']
  Godot Resource:
    description: |-
      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.
    links: {Reference: https://docs.godotengine.org/en/stable/tutorials/scripting/resources.html}
    source:
      Ext: [.tres]
      Fl: doc|xcfg
  Godot Scene:
    description: |-
      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.
    links: {Reference: https://docs.godotengine.org/en/stable/engine_details/file_formats/tscn.html}
    source:
      Ext: [.tscn]
      Fl: doc|xcfg
  GDShader:
    description: |-
      GDShader is a shading language used by the open-source Godot game
      engine for writing GPU programs that control how objects are
      rendered. Shader programs describe how vertices and fragments are
      processed in the graphics pipeline, allowing developers to implement
      custom visual effects, lighting models, and material behaviors. The
      language is integrated with Godot's rendering system and exposes
      built-in variables and functions for accessing geometry data,
      textures, and scene parameters. GDShader programs are compiled by the
      engine and executed on the graphics hardware as part of the rendering
      process.
    links: {Introduction: https://docs.godotengine.org/en/stable/tutorials/shaders/index.html, Repository: https://github.com/godotengine/godot}
    source:
      Ext: [.gdshader]
      Like: C-like
      Str: [['"', '"', bse]]
      Fl: xshd
  GML:
    description: |-
      GameMaker Language is a scripting language used in the GameMaker game
      development environment for implementing game logic, behaviors, and
      interactions. It provides constructs for variables, control flow, and
      functions, along with built-in features for manipulating game objects,
      events, and rendering. The language is designed to be accessible to
      beginners while supporting more advanced programming patterns for
      complete game development.
    links: {Website: https://manual.yoyogames.com/, Repository: https://github.com/YoYoGames/GameMaker-Manual}
    source:
      Ext: [.gml]
      Like: C-like
      Bc: [[/*, '*/'], [//, "\n"]]
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', 'repeat ', repeat(, '|| ', 'or ', '&& ', 'and ', '!= ', '== ']
  GoTemplate:
    description: |-
      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. Functionally this is Handlebars for Go.

      Note that this not the same as Templ, a templating system that
      wraps generation of HTML in Go syntax; they are inside-out
      with respect to each other.
    links: {Reference: https://pkg.go.dev/text/template}
    source:
      Ext: [.tmpl, .gohtml, .gotxt]
      Like: XML-like
      Bc: [['{{/*', '*/}}']]
      Str: [['`', '`', ml], ['"', '"', bse]]
      Co: ['{{if ', '{{ if ', '{{else', '{{ else', '{{range ', '{{ range ', '{{with', '{{ with']
      Fl: xtpl
  Grails:
    description: |-
      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.
    links: {Website: https://grails.org/}
    source:
      Ext: [.gsp]
      Bc: [[<%--, --%>]]
      Str: [[<%, '%>', ml]]
      Fl: xtpl
  GraphQL:
    description: |-
      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.
    links: {Website: https://spec.graphql.org/}
    source:
      Ext: [.graphql, .gql]
      Str: [['"""', '"""', bse|ml], ['"', '"', bse]]
      Co: ['type ', 'input ', 'query ', 'mutation ', 'subscription ', 'directive ', 'scalar ', 'enum ', 'interface ', 'union ', 'fragment ']
      Fl: xqry
      Bc: [['#', "\n"]]
  Groovy:
    description: |-
      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.
    links: {Website: https://groovy-lang.org/}
    source:
      Ext: [.groovy, .grt, .gtpl, .gvy]
      She: [groovy]
      Like: C-like
      Str: [[$/, /$, ml], ['"""', '"""', ml], ["'''", "'''", ml]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Gradle:
    description: |-
      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.
    links: {Reference: https://docs.gradle.org/current/userguide/userguide.html}
    source:
      Ext: [.gradle]
      Like: Groovy
      Fl: xbld
  Gradle Kotlin Script:
    aka: ['Gradle Kotlin DSL']
    description: |-
      Gradle Kotlin Script is the Kotlin-based DSL for Gradle build files.
      It provides statically typed build configuration while using the
      Gradle object model for declaring plugins, dependencies, tasks, and
      project settings. Files commonly use the compound suffix
      ".gradle.kts".
    links: {Reference: https://docs.gradle.org/current/userguide/kotlin_dsl.html}
    source:
      Ext: [.gradle.kts]
      Like: Kotlin
      Fl: xbld
  Gremlin:
    description: |-
      Gremlin is a graph traversal language used for querying and
      manipulating property graphs. Programs describe traversals that move
      through vertices and edges of a graph while applying filtering,
      aggregation, and transformation steps to the visited
      elements. Traversals are expressed as pipelines of operations that
      progressively refine a set of graph elements, allowing complex graph
      queries to be composed from smaller steps. The language is commonly
      used with graph databases and processing systems that implement the
      Apache TinkerPop framework, where it serves as the standard language
      for exploring graph structures and performing analytical or
      transactional graph operations.
    links: {Reference: https://tinkerpop.apache.org/gremlin.html, Repository: https://github.com/apache/tinkerpop}
    source:
      Ext: [.gremlin]
      Like: Groovy
      Fl: xqry
      Co: [.where(, .union(, .repeat(, .emit(, .and(, .or(, .not(, .as(, .by(]
  Hjson:
    description: |-
      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.
    links: {Website: https://hjson.github.io/}
    source:
      Ext: [.hjson]
      Str: [["'''", "'''", ml], ['"', '"', bse|ml], ['"', '"', bse]]
      Fl: xser
      Bc: [[//, "\n"], ['#', "\n"]]
  Hurl:
    description: |-
      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.
    links: {Website: https://hurl.dev/}
    source:
      Ext: [.hurl]
      Fl: xtst
      Bc: [['#', "\n"]]
  Gwion:
    description: |-
      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.
    links: {Website: https://gwion.github.io/}
    source:
      Ext: [.gw]
      Str: [['"', '"']]
      Co: ['fun ', while(, while (, repeat(, repeat (, if (, if(]
      Bc: [['#!', "\n"]]
      Fl: xaud
  Haml:
    description: |-
      Haml is an indentation-based templating language used mainly for HTML
      generation in Ruby web stacks.
    links: {Reference: https://haml.info/docs.html}
    source:
      Ext: [.haml]
      Fl: doc|xtpl
      Bc: [[-#, "\n", sol]]
  Hamlet:
    description: |-
      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.
    links: {Reference: https://www.yesodweb.com/book/shakespearean-templates}
    source:
      Ext: [.hamlet]
      Bc: [["<!--", "-->"], [$#, "\n", sol]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  Harbour:
    description: |-
      Harbour and xHarbour modern continuation of the xBase family designed
      for business application development, maintaining compatibility with
      legacy Clipper code while enabling integration with contemporary
      systems and toolchains. It is commonly used in environments where
      long-lived database-driven applications require portability and
      gradual modernization.
    links: {Reference: https://harbour.github.io/doc/, Repository: https://github.com/harbour/core}
    source:
      Ext: [.hb]
      Like: C
  Hare:
    description: |-
      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.
    links: {Website: https://harelang.org/}
    source:
      Ext: [.ha]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
      Co: ['for ', 'if ', 'else ', 'match ', 'switch ', '|| ', '&& ', '!= ', '== ']
  Haskell Boot:
    description: |-
      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.
    links: {Reference: https://downloads.haskell.org/~ghc/latest/docs/users_guide/separate_compilation.html#mutually-recursive-modules}
    source:
      Ext: [.hs-boot]
      Str: [['"', '"']]
  Haxe:
    description: |-
      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
    links: {Manual: https://haxe.org/manual}
    source:
      Ext: [.hx]
      Like: C-like
      Str: [[~/, /]]
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  HCL:
    description: |-
      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 - and the OpenTofu fork of Terraform - to
      describe infrastructure resources and configuration data in a
      declarative style.
    links: {Repository: https://github.com/hashicorp/hcl}
    source:
      Ext: [.hcl]
      Bc: [[/*, '*/'], [//, "\n"], ['#', "\n"]]
      Co: ['for_each ', 'for ', 'count ', coalesce(, '== ', '!= ', '> ', '< ', '&& ', '|| ']
      Fl: xcfg
  HEX:
    description: |-
      A catch-all for text files with the .hex extension, which are text
      versions of binary dumps that could be in any one of several formats
      including Intel Hex, Motorola S-Records, or vendor-specific dump
      formats
    source:
      Ext: [.hex]
      Fl: xser
  Hibernate:
    description: |-
      Hibernate is an object–relational mapping framework for Java that uses
      XML mapping files to describe how classes and their properties
      correspond to database tables and columns. These mapping definitions
      enable the framework to persist and retrieve objects while abstracting
      underlying relational database interactions.
    links: {Reference: https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html, Repository: https://github.com/hibernate/hibernate-orm}
    source:
      Ext: [.hbm.xml]
      Like: XML-like
      Fl: xcfg
  hledger:
    description: |-
      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.
    links: {Reference: https://hledger.org/manual.html}
    source:
      Ext: [.journal, .hledger, .j]
      Fl: xdsl
      Bc: [[;, "\n"]]
  HLSL:
    description: |-
      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.
    links: {Reference: https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl}
    source:
      Ext: [.hlsl, .fx, .fxh]
      Like: C-like
      St: ;
      Fl: xshd
  Hoon:
    description: |-
      Hoon is the primary programming language of the Urbit computing
      platform.  It is a functional language designed for deterministic
      computation and tightly integrated with the Nock virtual machine that
      forms the execution substrate of the Urbit system.
    links: {Reference: https://urbit.org/docs/hoon, Repository: https://github.com/urbit/urbit}
    source:
      Ext: [.hoon]
      Str: [['"', '"']]
      Co: ['%+  turn', '(turn ', '%+  roll', '(roll ', '%+  reel', '(reel ', '|.  ', '|.(', '|-  ', '|-(', '|?  ', '|?(', '?|  ', '?|(', '|(', '?-  ', '?-(', '?:  ', '?:(', '?.  ', '?.(', '?^  ', '?^(', '?<  ', '?<(', '?>  ', '?>(', '?+  ', '?+(', '?&  ', '?&(', '&(', '?@  ', '?@(', '?~  ', '?~(', '?=  ', '?=(', '.=  ', '=(', '!=(']
      Bc: [['::', "\n"]]
  HQL:
    description: |-
      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.
    links: {Reference: https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html}
    source:
      Ext: [.hql]
      Like: SQL-like
      Fl: xqry
  HTML:
    description: |-
      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.
    links: {Website: https://html.spec.whatwg.org/}
    source:
      Ext: [.html, .htm]
      Like: XML-like
      Fl: doc
  Imba:
    description: |-
      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.
    links: {Website: https://imba.io/}
    source:
      Ext: [.imba]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Bc: [['#', "\n"]]
  Hy:
    description: |-
      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.
    links: {Syntax reference: http://docs.hylang.org/en/stable/language/syntax.html#string-literals}
    source:
      Ext: [.hy]
      Str: [['"', '"', ml|bse]]
      Bc: [[;, "\n"]]
  Icon:
    description: |-
      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.
    links: {Reference: https://www2.cs.arizona.edu/icon/docs/icon-intro.pdf}
    source:
      Ext: [.icn]
      Str: [['"', '"', ml]]
      Bc: [['#', "\n"]]
  Idris:
    description: |-
      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.
    links: {Website: https://www.idris-lang.org/}
    source:
      Ext: [.idr]
      Like: Haskell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Inform 7:
    aka: [Inform7, I7]
    description: |-
      Inform 7 is a natural-language-based programming language for writing
      interactive fiction and related rule-based simulations. Source text is
      written as English-like assertions, rules, phrases, tables, scenes, and
      action definitions that describe a story world and how it responds to
      player commands. Inform translates this source into lower-level story
      code for virtual machines such as Glulx or the Z-machine, and also
      supports reusable extensions written in the same source language.
    links: {Website: https://ganelson.github.io/inform-website/, Reference: https://ganelson.github.io/inform-website/doc/}
    source:
      Ext: [.ni, .i7, .i7x]
      Bc: [['[', ']', cnest]]
      Str: [['"', '"']]
      Co: ['if ', 'otherwise', 'unless ', 'repeat ', 'while ', 'instead of ', 'before ', 'after ', 'check ', 'carry out ', 'report ', 'rule for ', 'every turn', 'when play begins', 'try ', 'decide ']
      Fl: xdsl
  Inno Setup:
    description: |-
      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.
    links: {Reference: https://jrsoftware.org/ishelp/}
    source:
      Ext: [.iss]
      Str: [['"', '"', ml]]
      Bc: [[;, "\n"], ['#', "\n"]]
      Fl: xbld
  INI:
    description: |-
      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,
    links: {Introduction: https://en.wikipedia.org/wiki/INI_file}
    source:
      Ext: [.ini]
      Str: [['"', '"', bse]]
      Fl: xcfg
      Bc: [[;, "\n"]]
  INTERCAL:
    description: |-
      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.
    links: {Website: https://www.catb.org/esr/intercal/}
    source:
      Ext: [.ick]
      Bc: [[NOTE, "\n"]]
  Io:
    description: |-
      Io is a small, prototype-based programming language designed for
      simplicity, uniformity, and extreme conceptual minimalism. It was
      created by Steve Dekorte.
    links: {Website: http://iolanguage.com/}
    source:
      Ext: [.io]
      Like: C-like
      Bc: [['#', "\n"]]
  Intel HEX:
    description: |-
      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. The extension is ".ihex".

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

      Files with a plain .hex extension may be in Intel hex format,
      but could also be Motorola SREC or other things.
    links: {Reference: https://en.wikipedia.org/wiki/Intel_HEX}
    source:
      Ext: [.ihex]
      Fl: xser
  Isabelle:
    description: |-
      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.
    links: {Reference: https://isabelle.in.tum.de/}
    source:
      Ext: [.thy]
      Bc: [[(*, '*)', cnest]]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xmat
  J:
    description: |-
      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.
    links: {Reference: https://www.jsoftware.com/help/}
    source:
      Ext: [.ijs]
      Str: [["'", "'"]]
      Bc: [[NB., "\n"]]
  Jai:
    description: |-
      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.
    links: {Introduction: https://github.com/BSVino/JaiPrimer}
    source:
      Ext: [.jai]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xprop
  Janet:
    description: |-
      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.
    links: {Website: https://janet-lang.org/}
    source:
      Ext: [.janet]
      Like: Lisp-like
      Co: ['(if ', '(for ', '(for ', '(cond ', '(switch ', '(when ', '(while ', '(loop ', '(case ']
  Java:
    description: |-
      Java is a general-purpose programming language created in the 1990s
      under the leadership of James Gosling as part of the Green project. It
      was designed for portability across platforms through compilation to
      an intermediate bytecode executed by the Java Virtual Machine,
      enabling programs to run unchanged on different operating systems and
      hardware architectures. The language became widely used for enterprise
      software, network services, and large-scale applications, and later
      expanded into web infrastructure, mobile development through Android,
      and distributed systems. Java is standardized through the Java
      Community Process and remains one of the most widely deployed
      programming platforms.
    links: {Website: https://openjdk.org/, Reference: https://docs.oracle.com/javase/specs/}
    source:
      Ext: [.java]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', 'else{', 'try ', 'try{', 'catch ', catch(, 'finally ', 'finally{', '|| ', '&& ', '!= ', '== ']
  JavaScript:
    description: |-
      JavaScript is a dynamic programming language originally created for
      scripting in web browsers. It evolved from a client-side scripting
      language into a general-purpose platform used for web applications,
      server-side development, and distributed services. The language is
      standardized as ECMAScript and is implemented in all major web
      browsers as well as in standalone runtimes such as Node.js, forming
      one of the core technologies of the modern web.
    links: {Introduction: https://developer.mozilla.org/en-US/docs/Web/JavaScript, Reference: https://tc39.es/ecma262/}
    source:
      Ext: [.js, .cjs]
      She: [node]
      Like: JavaScript-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', '?.', '?? ', '??= ']
  Jade:
    description: |-
      Jade was a template language used to generate HTML from a concise,
      indentation-based syntax.  It has been superseded by Pug.
    links: {Introduction: https://en.wikipedia.org/wiki/Pug_(template_engine)}
    source:
      Ext: [.jade]
      Str: [['"', '"']]
      Co: ['if ', 'else if ', 'unless ']
      Fl: xtpl
  Jam:
    description: |-
      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.
    links: {Reference: https://www.perforce.com/resources/documentation/jam}
    source:
      Ext: [.jam]
      Files: [Jamfile, Jamrules]
      Fl: xbld
      Bc: [['#', "\n"]]
  Jenkins Buildfile:
    description: |-
      Jenkins Buildfile, commonly called Jenkinsfile, is a configuration
      script used by the Jenkins automation server to define continuous
      integration and continuous delivery pipelines. The file describes
      build stages, steps, and execution conditions so that software builds,
      tests, and deployments can be executed automatically by
      Jenkins. Pipelines are written in a Groovy-based domain-specific
      language and are stored alongside project source code so that build
      logic is versioned and reproducible.
    links: {Introduction: https://www.jenkins.io/doc/book/pipeline/}
    source:
      Files: [Jenkinsfile]
      Like: Groovy
      Fl: xbld
  Jinja:
    aka: ['Jinja Templates']
    description: |-
      Jinja is a text-templating language most commonly used with Python,
      especially for HTML and configuration-file generation.
    links: {Reference: https://jinja.palletsprojects.com/en/stable/templates/}
    source:
      Ext: [.j2, .jinja, .jinja2]
      Bc: [['{#', '#}']]
      Co: ['{% for ', '{%- for ', '{% if ', '{%- if ', '{% else ', '{%- else ', '{% elif ', '{% macro ', '{%- macro ', '{% call ', '{%- call ', '{% filter ', '{%- filter ', '{% set ', '{% include ', '{% from ', '{% extends ', '{% with ']
      Fl: xtpl
  Jison:
    description: |-
      Jison is a parser generator for JavaScript with an API similar to
      Bison. Jison grammar files describe tokens, precedence declarations,
      start symbols, lexical rules, grammar productions, and JavaScript
      semantic actions, optionally embedding a lexer between %lex and /lex
      markers or using a separate lexical grammar file.
    links: {Documentation: https://techtonik.github.io/jison/docs/, Repository: https://github.com/zaach/jison}
    source:
      Ext: [.jison, .jisonlex]
      Like: JavaScript-like
      St: ;
      Co: ['%lex', '/lex', '%%', '%start ', '%token ', '%left ', '%right ', '%nonassoc ', '%prec ', '<<EOF>>', '|', '{', '}']
      Fl: xpld
  jq:
    description: |-
      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.
    links: {Reference: https://jqlang.github.io/jq/manual/}
    source:
      Ext: [.jq]
      Str: [['"', '"', bse]]
      Co: [., 'if ', 'elif ', 'else ', '!= ', '== ', '>= ', '<= ', '< ', '> ', 'and ', 'or ', 'not ', '// ', 'try ', 'break ']
      Fl: xqry
      Bc: [['#', "\n"]]
  JOSS:
    description: |-
      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.
    links: {Reference: https://www.rand.org/content/dam/rand/pubs/research_memoranda/2008/RM5478.pdf}
    source:
      Ext: [.joss]
      Str: [['"', '"']]
      Fl: xdead
      Bc: [[Note, "\n"]]
  JSON5:
    description: |-
      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.
    links: {Website: https://spec.json5.org/}
    source:
      Ext: [.json5]
      Bc: [[/*, '*/'], [//, "\n"]]
      Like: JSON-like
  JSONC:
    description: |-
      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.
    links: {Repository: https://github.com/microsoft/node-jsonc-parser}
    source:
      Ext: [.jsonc]
      Bc: [[/*, '*/'], [//, "\n"]]
      Like: JSON-like
  JSONL:
    description: |-
      JSONL, also known as JSON Lines or NDJSON, is a line-oriented data
      format in which each line of a text file contains a complete JSON
      value. The format is designed for efficient streaming and processing
      of structured data. A JSONL file consists of a sequence of records
      separated by newline characters. Each line must contain exactly one
      valid JSON value, typically a JSON object but potentially any valid
      JSON value such as an array, string, number, boolean, or null.
    links: {Website: https://jsonlines.org/}
    source:
      Ext: [.jsonl, .ndjson]
      Like: JSON-like
  JSON-LD:
    aka: ['JavaScript Object Notation for Linked Data']
    description: |-
      JSON-LD is a JSON-based serialization format for Linked Data. JSON-LD
      documents use ordinary JSON syntax with terms such as @context, @id,
      @type, @graph, language maps, lists, sets, and IRI mappings to express
      RDF graphs and related linked-data structures in a form that can be
      consumed by JSON tooling.
    links: {Reference: https://www.w3.org/TR/json-ld11/, Website: https://json-ld.org/}
    source:
      Ext: [.jsonld]
      Like: JSON-like
  Jsonnet:
    description: |-
      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.
    links: {Website: https://jsonnet.org/}
    source:
      Ext: [.jsonnet, .libsonnet]
      She: [jsonnet]
      Like: C-like
      Str: [['|||', '|||', ml]]
      Co: [for, if, else, '||', '&&', '!=', ==]
      Fl: xtpl
  JSLT:
    description: |-
      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.
    links: {Reference: https://github.com/schibsted/jslt}
    source:
      Ext: [.jslt]
      Str: [['"', '"', bse]]
      Bc: [[//, "\n"]]
      Fl: xqry|xtrn
  JSP:
    description: |-
      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.
    links: {Reference: https://jakarta.ee/specifications/pages/}
    source:
      Ext: [.jsp, .jspf]
      Bc: [[<%--, --%>]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  JSX:
    description: |-
      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.
    links: {Reference: https://react.dev/learn/writing-markup-with-jsx}
    source:
      Ext: [.jsx]
      Like: JavaScript-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Julius:
    description: |-
      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.
    links: {Reference: https://www.yesodweb.com/book/shakespearean-templates}
    source:
      Ext: [.julius]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
      Bc: [[$#, "\n", sol]]
  Jupyter:
    description: |-
      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.
    links: {Website: https://nbformat.readthedocs.io/}
    source:
      Ext: [.ipynb]
      Like: JSON-like
      Fl: doc|xdsl
  Just:
    description: |-
      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.
    links: {Website: https://just.systems/}
    source:
      Ext: [.just]
      Files: [justfile]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [['#', "\n"]]
  K:
    description: |-
      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.
    links: {Reference: https://code.kx.com/q/learn/k-language/}
    source:
      Ext: [.k]
      Str: [["'", "'"]]
      Co: ["'", /, \, "':", '/:', '\:', '|', '&', '!', '=']
      Bc: [[/, "\n"]]
  Kaem:
    description: |-
      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.
    links: {Reference: https://bootstrapping.miraheze.org/wiki/Stage0}
    source:
      Ext: [.kaem]
      Str: [['"', '"', ml|bse]]
      Fl: xdsl
      Bc: [['#', "\n"]]
  Kaitai Struct:
    description: |-
      Kaitai Struct is a declarative language for describing binary file
      formats, network packet formats, firmware structures, and other
      binary data layouts. Kaitai Struct specifications are YAML-based
      files that define metadata, byte sequences, primitive and user-defined
      types, enums, instances, conditional fields, repetitions, validation,
      and processing rules that can be compiled into parsers for multiple
      target languages.
    links: {Website: https://kaitai.io/, User Guide: https://doc.kaitai.io/user_guide.html, Formats Repository: https://github.com/kaitai-io/kaitai_struct_formats}
    source:
      Ext: [.ksy]
      Like: YAML-like
      #Require: ['^\s*(?:meta|seq|types|enums|instances):|^\s*-\s+id:\s*[A-Za-z0-9_][A-Za-z0-9_-]*|^\s*(?:type|size|contents|repeat|repeat-expr|if|io|pos|process):\s*']
      Fl: xpld
  KiCad PCB:
    aka: ['KiCad board file']
    description: |-
      KiCad PCB files are native KiCad board layout files written in its
      s-expression file format. They describe printed circuit boards with
      board metadata, layers, setup data, nets, footprints, tracks, vias,
      zones, graphics, embedded images, groups, properties, and plotting
      or manufacturing settings.
    links: {Board Format: https://dev-docs.kicad.org/en/file-formats/sexpr-pcb/, S-Expression Format: https://dev-docs.kicad.org/en/file-formats/sexpr-intro/, File List: https://docs.kicad.org/9.0/en/kicad/kicad.html#kicad-files-and-folders}
    source:
      Ext: [.kicad_pcb]
      Str: [['"', '"', bse]]
      #Require: ['^\s*\(kicad_pcb\b']
      Co: ['(layers ', '(setup ', '(property ', '(net ', '(footprint ', '(pad ', '(segment ', '(via ', '(arc ', '(zone ', '(gr_line ', '(gr_arc ', '(gr_poly ', '(gr_text ', '(image ', '(group ']
      Fl: xhdl
  Kconfig:
    description: |-
      Kconfig is the configuration language used by the Linux kernel build
      system and by related projects to describe selectable build options,
      menus, dependencies, defaults, help text, and source-file inclusion.
      Kconfig files define a configuration tree that tools such as
      menuconfig use to derive generated build configuration.
    links: {Reference: https://www.kernel.org/doc/html/v6.15/kbuild/kconfig-language.html}
    source:
      Ext: [.kconfig]
      Files: [Kconfig]
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Fl: xcfg
  KDL:
    description: |-
      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.
    links: {Website: https://kdl.dev/}
    source:
      Ext: [.kdl]
      Like: C-like
      Fl: xser
  KakouneScript:
    description: |-
      KakouneScript is the command and configuration language of the Kakoune
      editor. It is used to define editor commands, key mappings, hooks, and
      configuration behavior.
    links: {Repository: https://github.com/mawww/kakoune}
    source:
      Like: 'Shell-like'
      Ext: ['.kak']
      Files: ['kakrc']
      Fl: ['xdsl']
  Kermit Script:
    description: |-
      Kermit Script is the command and scripting language used by Kermit
      communications software to automate file transfer, terminal sessions,
      and communication workflows. It provides structured control flow and
      command-driven interaction with communication devices and protocols,
      enabling automation of tasks such as dialing, logging in, and
      transferring files.
    links: {Reference: https://www.kermitproject.org/ckermit.html, Repository: https://github.com/davidrg/ckermit}
    source:
      Ext: [.ksc, .ks]
      Bc: [[;, "\n"]]
      Fl: xdsl
  Kotlin:
    description: |-
      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.
    links: {Reference: https://kotlinlang.org/docs/reference/}
    source:
      Ext: [.kt]
      Like: C-like
      Str: [['"""', '"""', ml]]
      Co: ['for ', for(, 'if ', if(, 'when ', when(, 'while ', while(, 'else ', 'else{', 'try ', 'try{', 'catch ', catch(, 'finally ', 'finally{', '|| ', '&& ', '!= ', '== ']
      Fl: ktl
  Kotlin Script:
    description: |-
      Kotlin Script is Kotlin source intended to be executed as a
      script.  It uses Kotlin syntax with top-level executable
      statements and is used for automation, configuration, and
      lightweight command-line tasks.
    links: {Reference: https://kotlinlang.org/docs/command-line.html#run-scripts}
    source:
      Ext: [.kts]
      Like: Kotlin
  Koto:
    description: |-
      Koto is a lightweight scripting language designed for embedding in
      Rust applications and for general scripting. Programs consist of
      expressions evaluated in sequence, with assignment using = and
      function definitions written with vertical-bar parameter lists such as
      |x, y|. Strings support interpolation using braces inside quoted
      text. Collections include lists written with [] and maps written with
      {} or with indentation-based entry blocks. Map keys commonly use
      identifier-style syntax and are accessed with the dot
      operator. Functions and values participate in a pipeline style of
      evaluation using the >> operator, allowing expressions to be
      chained. Indentation can be used for structural layout in constructs
      such as map literals and blocks. Anonymous functions, tuple literals,
      ranges, and method-style calls on values using dot notation are also
      part of the core syntax.
    links: {Website: https://koto.dev/, Reference: https://koto.dev/docs/, Repository: https://github.com/koto-lang/koto}
    source:
      Ext: [.koto]
      Bc: [['#-', -#], ['#', "\n"]]
      Co: ['for ', 'while ', 'until ', 'continue ', 'break ', 'loop ', 'if ', 'switch ', 'match ', then, 'else ', '|| ', '&& ', '!= ', '== ', 'and ', 'or ', 'not ']
  ksh:
    aka: ['Korn Shell']
    description: |-
      ksh is a Unix shell and command language originating from AT&T Bell
      Labs, designed as an enhanced successor to earlier Bourne-style
      shells. It provides a rich scripting environment with features for
      process control, arithmetic, and interactive use, and has influenced
      many later shells including Bash.
    links: {Reference: https://www.kornshell.com/doc/, Repository: https://github.com/ksh93/ksh}
    source:
      Ext: [.ksh]
      Files: [.kshrc]
      She: [ksh]
      Like: Shell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  KVLang:
    description: |-
      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.
    links: {Website: https://kivy.org/}
    source:
      Ext: [.kv]
      Str: [['"', '"', bse|ml], ["'", "'", ml], ['"', '"', bse]]
      Fl: xidl
      Bc: [['#', "\n"]]
  LALRPOP:
    description: |-
      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.
    links: {Website: https://lalrpop.github.io/lalrpop/}
    source:
      Ext: [.lalrpop]
      Like: C-like
      Str: [['(?:b)?r(#{0,255})"', '"&', ml|re], ['"', '"', bse], ["'", "'", bse]]
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', 'match ']
      Fl: xpld
  Langium:
    description: |-
      Langium grammar files define domain-specific languages for the
      Langium language engineering framework, serving JavaScript and
      TypeScript.  They describe parser rules, terminal rules, hidden
      terminals, imports, interfaces, types, infix operators,
      assignments, actions, cross references, guard conditions, and
      regular-expression terminals used to generate parsers, AST
      types, and language-server infrastructure.
    links: {Reference: https://langium.org/docs/reference/grammar-language/, Repository: https://github.com/eclipse-langium/langium}
    source:
      Ext: [.langium]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['/(\\.|[^\\/*+?])', '/', bse|re], ['"', '"', bse], ["'", "'", bse]]
      St: ;
      #Require: ['^\s*(?:grammar|import|entry|terminal|hidden\s+terminal|interface|type|infix)\b|^\s*(?:fragment\s+)?[A-Za-z_][A-Za-z0-9_]*(?:<[^>\n]+>)?\s*(?:(?:returns|infers)\s+[A-Za-z_][A-Za-z0-9_]*\s+)?\:']
      Co: ['entry ', 'terminal ', 'hidden ', 'fragment ', 'interface ', 'type ', 'infix ', 'returns ', 'infers ', 'import ', '|', '&', '?', '*', '+', '->', '=>']
      Fl: xpld
  Lark:
    description: |-
      Lark grammar files define grammars for the Lark parsing toolkit. They
      use an EBNF-based notation with lowercase rules, uppercase terminals,
      quoted string literals, regular-expression terminals, priorities,
      aliases, templates, and directives such as %import, %ignore,
      %declare, %override, and %extend.
    links: {Reference: https://lark-parser.readthedocs.io/en/stable/grammar.html, Repository: https://github.com/lark-parser/lark}
    source:
      Ext: [.lark]
      Bc: [[//, "\n"], ['#', "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      #Require: ['^\s*(?:%import|%ignore|%declare|%override|%extend)\b|^\s*[A-Z_][A-Z0-9_]*(?:\.[-+]?\d+)?\s*:|^\s*[a-z_][a-z0-9_]*(?:\.[-+]?\d+)?\s*:']
      Co: ['|', '?', '*', '+', '~ ', '-> ', '%import ', '%ignore ', '%declare ', '%override ', '%extend ']
      Fl: xpld
  Lean:
    description: |-
      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.
    links: {Website: https://lean-lang.org/}
    source:
      Ext: [.lean]
      Bc: [[/-, -/, cnest], [--, "\n"]]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xmat
  Lem:
    description: |-
      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.
    links: {Reference: https://github.com/rems-project/lem}
    source:
      Ext: [.lem]
      Bc: [["(*", "*)"]]
      Str: [['"', '"']]
      Fl: xdsl
  Less:
    aka: [LESS]
    description: |-
      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.
    links: {Website: https://lesscss.org/}
    source:
      Ext: [.less]
      Bc: [[/*, '*/']]
      Str: [['"', '"']]
      Fl: xtpl
  LFE:
    description: |-
      LFE is a Lisp dialect that runs on the Erlang virtual machine,
      combining Lisp syntax with Erlang's concurrency and fault-tolerance
      model. It enables developers to write programs using symbolic
      expressions while interoperating directly with Erlang libraries and
      runtime behavior.
    links: {Website: https://lfe.io/, Repository: https://github.com/lfe/lfe}
    source:
      Ext: [.lfe]
      Like: Lisp-like
  License:
    description: |-
      This category recognizes conventional names for license files.
    source:
      Files: [license, licence, copying, copying3, unlicense, unlicence, license-apache, licence-apache, license-mit, licence-mit, copyright]
  LinguaFranca:
    description: |-
      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.
    links: {Website: https://www.lf-lang.org/}
    source:
      Ext: [.lf]
      Like: C-like
      St: ;
      Fl: xdsl
  LinkerScript:
    aka: ['LD Script']
    description: |-
      GNU ld linker scripts are declarative control files for output sections
      and memory layout.
    links: {GNU ld linker scripts: https://sourceware.org/binutils/docs/ld/Scripts.html}
    source:
      Ext: [.ld, .lds]
      Bc: [[/*, '*/']]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xirf
  Liquid:
    description: |-
      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.

      Not to be confused with the Liquibase schema change manager.
    links: {Website: https://shopify.github.io/liquid/}
    source:
      Ext: [.liquid]
      Like: XML-like
      Fl: xtpl
  Lisp:
    description: |-
      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.
    links: {Reference: https://www.lispworks.com/documentation/HyperSpec/Front/index.htm}
    source:
      Ext: [.lisp, .lsp, .cl]
      She: [sbcl]
      Like: Lisp-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  LiveLink OScript:
    description: |-
      LiveLink OScript is a scripting and extension language used in
      OpenText LiveLink (Content Server) to customize application behavior,
      workflows, and integrations. It provides procedural constructs and
      access to the system's object model, enabling server-side
      customization within the LiveLink environment.
    links: {Reference: https://knowledge.opentext.com/}
    source:
      Ext: [.os]
      Like: C-like
  LiveScript:
    description: |-
      LiveScript is a functional, expressive language that compiles to
      JavaScript. It evolved from CoffeeScript but emphasizes more powerful
      syntax, functional programming constructs, and conciseness.
    links: {Website: https://livescript.net/}
    source:
      Ext: [.ls]
      Bc: [[/*, '*/'], ['#', "\n"]]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", ml], ['"', '"', ml|bse], ["'", "'", ml]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'case ', 'while ', 'when ', 'else ', '|| ', '&& ', '!= ', '!== ', 'xor ', 'and ', 'or ', '|> ', '<< ', '<<< ', '<<<< ', '>> ', '== ']
  LLVM IR:
    aka: [LLVM]
    description: |-
      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.
    links: {Reference: https://llvm.org/docs/LangRef.html}
    source:
      Ext: [.ll]
      Str: [['"', '"', bse]]
      Co: [llvm.loop, 'br ', 'switch ', 'indirectbr ', 'invoke ', 'callbr ', 'resume ', 'catchswitch ', 'catchret ', 'cleanupret ', 'shl ', 'lshr ', 'ashr ', 'and ', 'or ', 'xor ']
      Fl: xirf
      Bc: [[;, "\n"]]
  Logo:
    description: |-
      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.
    links: {Reference: https://people.eecs.berkeley.edu/~bh/v2ch14/manual.html}
    source:
      Ext: [.lg]
      Bc: [[;, "\n"], ['#', "\n"]]
  Logtalk:
    description: |-
      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.
    links: {Website: https://logtalk.org/}
    source:
      Ext: [.lgt]
      Bc: [[/*, '*/'], ['%', "\n"]]
      St: .
  lua:
    aka: [Lua]
    description: |-
      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.
    links: {Reference: https://www.lua.org/manual/}
    source:
      Ext: [.lua]
      She: [lua]
      Bc: [['--\[(=*)\[', ']&]', re], [--, "\n"]]
      Str: [['\[(=*)\[', ']&]', ml|re], ['"', '"', bse], ["'", "'", bse]]
      Co: ['for ', for(, 'if ', if(, 'while ', while(, 'else ', else(, 'elseif ', elseif(, 'until ', until(, 'or ', 'and ', '~= ', '== ']
  Luau:
    description: |-
      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.
    links: {Website: https://luau-lang.org/}
    source:
      Ext: [.luau]
      She: [luau]
      Bc: [['--\[(=*)\[', ']&]', re], [--, "\n"]]
      Str: [['\[(=*)\[', ']&]', ml|re], ['"', '"', bse], ["'", "'", bse]]
      Co: ['for ', for(, 'if ', if(, 'while ', while(, 'else ', else(, 'elseif ', elseif(, 'until ', until(, 'or ', 'and ', '~= ', '== ']
  Lucius:
    description: |-
      Lucius is a stylesheet templating language used by the Yesod web
      framework for the Haskell programming language. It allows CSS rules to
      be written with variables, nesting, and template interpolation so that
      stylesheets can be generated dynamically as part of web application
      code. Lucius templates are compiled by Yesod into standard CSS that is
      served to the browser.
    links: {Reference: https://www.yesodweb.com/book/shakespearean-templates, Repository: https://github.com/yesodweb/shakespeare/blob/master/Text/Lucius.hsb}
    source:
      Ext: [.lucius]
      Like: CSS
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  M3U:
    description: |-
      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.
    links: {Reference: https://datatracker.ietf.org/doc/html/rfc8216}
    source:
      Ext: [.m3u, .m3u8]
      Fl: xser
      Bc: [['#', "\n"]]
  m4:
    aka: [M4]
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/m4/manual/}
    source:
      Ext: [.m4]
      Str: [['"', '"']]
      Bc: [['#', "\n"]]
  MAD:
    description: |-
      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.
    links: {Reference: https://bitsavers.org/pdf/univOfMichigan/mad/}
    source:
      Ext: [.mad]
      Fl: xdead
      Bc: [[R, "\n"]]
  Makefile:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/make/manual/}
    source:
      Ext: [.mk]
      Files: [makefile, imakefile, gnumakefile]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [['#', "\n"]]
  Mako:
    description: |-
      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.
    links: {Reference: https://www.makotemplates.org/}
    source:
      Ext: [.mako]
      Str: [[<%, '%>', ml]]
      Co: ['% for ', '% if ', '% else ', '% elif ', '<% include ', '<%def ', '<%page ', '<%def ', '<%block ', '<%namespace ', '<%inherit ']
      Fl: xtpl
      Bc: [['##', "\n"]]
  mal:
    description: |-
      Mal is a small pedagogic Lisp with multiple implementations that
      follow the Make-A-Lisp process.
    links: {Repository: https://github.com/kanaka/mal}
    source:
      Ext: [.mal]
      Like: Lisp-like
  man:
    description: |-
      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.
    links: {Reference: https://man7.org/linux/man-pages/man7/man.7.html}
    source:
      Ext: [.man, '.1', '.2', '.3', '.4', '.5', '.6', '.7', '.8']
      Like: roff-like
      Fl: doc
  MapCSS:
    description: |-
      A stylesheet language used in the OpenStreetMap ecosystem to define
      rules for rendering map features based on their tags and properties,
      enabling customizable visual representations of geographic data.
    links: {Specification: https://wiki.openstreetmap.org/wiki/MapCSS}
    source:
      Ext: [.mapcss]
      Like: CSS
      Fl: xtpl
  Maple:
    description: |-
      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.
    links: {Reference: https://www.maplesoft.com/products/Maple/}
    source:
      Ext: [.mpl]
      Str: [['"', '"', bse]]
      Fl: xprop|xmat
      Bc: [['#', "\n"]]
  Markdown:
    description: |-
      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.
    links: {Reference: https://daringfireball.net/projects/markdown/}
    source:
      Ext: [.md]
      Fl: doc
  Maxima:
    description: |-
      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.
    links: {Website: https://maxima.sourceforge.io/}
    source:
      Ext: [.mac, .max]
      Bc: [[/*, '*/']]
      Str: [['"', '"', bse]]
      Fl: xmat
  Maven:
    description: |-
      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.
    links: {Website: https://maven.apache.org/guides/}
    source:
      Ext: [.maven]
      Like: XML-like
      Fl: xbld
  MDX:
    description: |-
      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.
    links: {Website: https://mdxjs.com/}
    source:
      Ext: [.mdx]
      Fl: doc
  Mermaid:
    description: |-
      Mermaid is a text-based diagram description language used to generate
      flowcharts, sequence diagrams, class diagrams, and other
      visualizations from concise textual definitions. It is commonly
      embedded in documentation systems and markup environments so that
      diagrams can be written alongside source text and rendered
      automatically by supporting tools.
    links: {Website: https://mermaid.js.org/, Repository: https://github.com/mermaid-js/mermaid}
    source:
      Ext: [.mmd, .mermaid]
      Bc: [['%%', "\n"]]
      Fl: xmdl
  Meson:
    description: |-
      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.
    links: {Reference: https://mesonbuild.com/Syntax.html}
    source:
      Ext: [.meson]
      Str: [["'''", "'''", bse|ml], ["'", "'", bse]]
      Co: ['foreach ', 'if ', 'elif ', 'unless ', 'and ', 'or ', 'else ']
      Fl: xbld
      Bc: [['#', "\n"]]
  MIB:
    description: |-
      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.
    links: {Reference: https://datatracker.ietf.org/doc/html/rfc2580}
    source:
      Ext: [.mib, .my]
      Str: [['"', '"']]
      Fl: xcfg
      Bc: [[--, "\n"]]
  MiniZinc:
    aka: [FlatZinc]
    description: |-
      MiniZinc is a high-level constraint-modeling language for describing
      and solving discrete satisfaction and optimization problems. MiniZinc
      files define parameters, variables, arrays, sets, constraints,
      predicates, functions, solve goals, and output items. Related data
      files provide model instances, and FlatZinc files are the lower-level
      solver-independent target form generated from MiniZinc models.
    links: {Website: https://www.minizinc.org/, Reference: https://docs.minizinc.dev/en/stable/spec.html, FlatZinc: https://docs.minizinc.dev/en/stable/fzn-spec.html}
    source:
      Ext: [.mzn, .dzn, .fzn]
      Bc: [[/*, '*/'], ['%', "\n"]]
      Str: [['"', '"', bse], ["'", "'"]]
      St: ;
      Co: ['constraint ', 'solve ', 'if ', 'then ', 'else ', 'endif ', 'forall ', 'exists ', 'where ', 'not ', 'and ', 'or ', 'xor ', '->', '<->', '!= ', '== ']
      Fl: xmat
  Mint:
    description: |-
      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.
    links: {Website: https://www.mint-lang.com/}
    source:
      Ext: [.mint]
      Bc: [[/*, '*/']]
      Str: [['"', '"', ml]]
  MLIR:
    description: |-
      MLIR is the Multi-Level Intermediate Representation framework in
      LLVM. Its textual form is a human-readable intermediate representation
      built around operations, regions, blocks, values, attributes, and
      extensible dialects, so it fits best here as a domain-specific
      language rather than a general-purpose programming language. The
      official language reference documents // line comments in examples and
      grammar-oriented descriptions of the textual form.
    links: {Website: https://mlir.llvm.org, Repository: https://github.com/llvm/llvm-project/tree/main/mlir}
    source:
      Ext: [.mlir]
      Str: [['"', '"']]
      Co: ['affine.for ', 'affine.if ', 'else ', 'else{', 'cf.switch ', 'cf.br ', cf.cond_br, 'scf.for ', 'scf.forall ', 'scf.forall{', 'scf.forall.in_parallel ', 'scf.forall.in_parallel{', 'scf.if ', 'scf.index_switch ', 'scf.while ', 'arith.cmpi eq,', 'arith.cmpi ne,', 'index.cmp eq,', 'index.cmp ne,']
      Fl: xirf
      Bc: [[//, "\n"]]
  Modula:
    description: |-
      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.
    links: {Reference: https://people.inf.ethz.ch/wirth/Modula/Modula.html}
    source:
      Ext: [.mod]
      Like: Pascal-like
      St: ;
      Sb: BEGIN
      Eb: END
      Str: [["'", "'"]]
      Fl: xdead
  Modula2:
    description: |-
      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.
    links: {Website: https://www.modula2.org/}
    source:
      Ext: [.i2, .m2]
      Like: Pascal-like
      St: ;
      Sb: BEGIN
      Eb: END
      Str: [['"', '"']]
      Fl: xdead
  Modula3:
    description: |-
      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.
    links: {Reference: https://modula3.elegosoft.com/cm3/doc/reference/}
    source:
      Ext: [.i3, .m3, .ig, .mg]
      Like: Pascal-like
      St: ;
      Sb: BEGIN
      Eb: END
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdead
  Mog:
    description: |-
      Mog is a small programming language designed to support
      machine-generated programs and lightweight embedded scripting. Its
      design focuses on keeping the language specification compact while
      still allowing structured programs with functions, expressions, and
      basic data structures. The language is intended to be embedded in host
      systems where generated programs can be compiled and executed under
      controlled conditions, enabling applications to load externally
      produced code while maintaining predictable behavior and manageable
      complexity.
    links: {Website: https://moglang.org}
    source:
      Ext: [.mog]
      Like: C-like
      Co: ['for ', 'if ', if(, 'while ', while(, 'else ', 'match ', 'or ', 'and ', '|| ', '&& ', '!= ', '== ', 'catch ', catch(, 'try ']
  Mojo:
    description: |-
      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.
    links: {Website: https://www.modular.com/mojo}
    source:
      Ext: [.mojo]
      Like: Python-like
      Co: ['for ', for(, 'while ', while(, 'if ', if(, 'elif ', elif(, 'else ', 'else:', 'try ', 'try:', 'except ', 'except:', 'finally ', 'finally:', 'with ', with (, 'and ', and(, 'or ', or(, '== ', '!= ']
  Mojom:
    description: |-
      Mojom is an interface definition language used in the Chromium project
      to describe message-passing interfaces between components and
      processes. It defines services, methods, and data structures that are
      compiled into bindings for multiple programming languages, enabling
      structured inter-process communication within the Chromium
      architecture.
    links: {Reference: https://chromium.googlesource.com/chromium/src/+/main/mojo/README.md, Repository: https://chromium.googlesource.com/chromium/src/+/main/mojo}
    source:
      Ext: [.mojom]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", ml|bse]]
      Fl: xidl
  MoonBit:
    description: |-
      MoonBit is a general-purpose language specifically adapted for for
      programming AI agents. Built-in constructs also include test blocks
      for inline unit tests.
    links: {Website: https://www.moonbitlang.com/, Documentation: https://docs.moonbitlang.com/, Repository: https://github.com/moonbitlang/core}
    source:
      Ext: [.mbt]
      Like: C-like
      Co: ['for ', 'if ', 'switch ', 'while ', 'else ', 'loop ', 'guard ', '|| ', '&& ', '!= ', '== ', 'match ']
  MoonScript:
    description: |-
      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.
    links: {Reference: https://moonscript.org/reference/}
    source:
      Ext: [.moon]
      Str: [['"', '"', ml|bse]]
      Bc: [[--, "\n"]]
  Move:
    description: |-
      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.
    links: {Website: https://move-language.github.io/}
    source:
      Ext: [.move]
      Like: C-like
      St: ;
      Fl: xctr
  MSBuild:
    description: |-
      MSBuild is a build configuration and orchestration system used in the
      the .NET ecosystem to define how projects are compiled, packaged, and
      processed. It uses declarative project files to specify properties,
      items, and targets that control the build process and enable
      extensible automation of development workflows.
    links: {Reference: https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild, Repository: https://github.com/dotnet/msbuild}
    source:
      Ext: [.csproj, .vbproj, .fsproj, .props, .targets]
      Like: XML-like
      Co: [Condition]
      Fl: xbld
  Mustache:
    description: |-
      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.
    links: {Reference: https://mustache.github.io/mustache.5.html}
    source:
      Ext: [.mustache]
      Bc: [['{{!', '}}']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  MXML:
    description: |-
      MXML (Macromedia eXtensible Markup Language) is an XML-based markup
      language originally developed for Flex for defining user interface
      layouts and application structure. It allows developers to declare UI
      components, properties, and event handlers in a structured form that is
      compiled into ActionScript code. MXML is used to build rich internet
      applications by combining declarative interface definitions with
      program logic.

      The Apache Flex project maintains an open-source implementation, but
      the original Flex/Flash deployment model has been effectively dead
      since Flash Player reached end of life in 2020.
    links: {Reference: https://flex.apache.org/doc/flex/using/flx_mxml_mx.html, Repository: https://github.com/apache/flex-sdk}
    source:
      Ext: [.mxml]
      Like: XML-like
      Fl: xtpl|xdsl|xdead
  .NET Resource:
    description: |-
      A format used in the Microsoft .NET ecosystem to store localized
      strings, UI assets, and other embedded data that can be accessed by
      applications at runtime. It supports culture-specific variants to
      enable internationalization and separation of user-facing content from
      executable logic.
    links: {Reference: https://learn.microsoft.com/en-us/dotnet/core/extensions/resources}
    source:
      Ext: [.resx, .resources]
      Like: XML-like
      Fl: xcfg
  Nearley:
    description: |-
      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.
    links: {Website: https://nearley.js.org/}
    source:
      Ext: [.ne]
      Fl: xpld
      Bc: [['#', "\n"]]
  NetLogo:
    description: |-
      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.
    links: {Website: https://ccl.northwestern.edu/netlogo/}
    source:
      Ext: [.nlogo]
      Str: [['"', '"', bse]]
      Bc: [[;, "\n"]]
  Nextflow:
    description: |-
      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.
    links: {Reference: https://www.nextflow.io/docs/latest/}
    source:
      Ext: [.nextflow, .nf]
      Like: Groovy
      Fl: xdsl
  Nial:
    description: |-
      Nial is an array-oriented programming language developed at Queen's
      University in the 1980s.  The name stands for Nested Interactive Array
      Language and reflects the central concept that arrays may contain
      other arrays as elements, allowing deeply nested data structures to be
      manipulated directly.
    links: {Introduction: https://en.wikipedia.org/wiki/Nial, Repository: https://github.com/danlm/QNial7}
    source:
      Ext: [.ndf]
      Str: [["'", "'"]]
      Co: ['case ', 'for ', 'if ', 'repeat ', 'while ', 'or ', 'and ', '= ', 'equal ', '~= ', 'unequal ']
      Fl: xdead
      Bc: [['%', "\n"]]
  Nickel:
    description: |-
      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.
    links: {Website: https://nickel-lang.org/}
    source:
      Ext: [.ncl]
      Bc: [[/*, '*/'], ['#', "\n"]]
      Str: [['"', '"', bse]]
      Fl: xdsl
  nftables:
    aka: [nft]
    description: |-
      nftables is the configuration and command language for Linux packet
      filtering managed by the nft utility. nftables files define tables,
      chains, sets, maps, and rules for firewall policy, address
      translation, packet changes, and packet filtering. Scripts can be
      loaded by nft from a file.
    links: {Reference: https://wiki.nftables.org/wiki-nftables/index.php/Scripting, Manual: https://manpages.debian.org/bookworm/nftables/nft.8.en.html}
    source:
      Ext: [.nft, .nftables]
      Files: [nftables.conf]
      She: [nft]
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse]]
      Fl: xcfg
  Nim:
    description: |-
      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.
    links: {Reference: https://nim-lang.org/docs/manual.html}
    source:
      Ext: [.nim]
      Bc: [['#[', ']#', cnest], ['#', "\n"]]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", ml], ['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Ninja:
    description: |-
      Ninja is a low-level build-system language and tool designed to run
      generated build graphs quickly. Ninja files describe rules, build
      edges, variables, default targets, pools, and included sub-build files;
      they are commonly generated by higher-level meta-build systems such as
      CMake, Meson, and GN.
    links: {Reference: https://ninja-build.org/manual}
    source:
      Ext: [.ninja]
      Bc: [['#', "\n"]]
      Fl: xbld
  NSIS:
    description: |-
      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.
    links: {Reference: https://nsis.sourceforge.io/Docs/}
    source:
      Ext: [.nsi, .nsh]
      Bc: [[/*, '*/'], [;, "\n"], ['#', "\n"]]
      Str: [['"', '"', ml]]
      Fl: xbld
  Nix:
    description: |-
      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.
    links: {Reference: https://nixos.org/manual/nix/stable/language/}
    source:
      Ext: [.nix]
      Bc: [[/*, '*/'], ['#', "\n"]]
      Str: [["''", "''", ml], ['"', '"', ml|bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcfg
  NotQuitePerl:
    aka: ['Not Quite Perl', NQP]
    description: |-
      NotQuitePerl, usually abbreviated NQP ("Not Quite Perl"), is a
      lightweight Raku-like language used primarily for implementing
      compilers and low-level runtime libraries on virtual machines such as
      MoarVM, the JVM, and JavaScript backends. It is designed to keep a
      small runtime footprint while still providing a Raku object model and
      regular expression engine, and it is used in the implementation of
      Rakudo and related tooling.
    links: {Website: https://github.com/Raku/nqp, Reference: https://docs.raku.org/language/glossary#NQP}
    source:
      Ext: [.nqp]
      She: [nqp]
      St: ;
      Bc: [['#', "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", ml|bse]]
      Lrb: '^=begin(?:\s|$)'
      Lre: '^=end(?:\s|$)'
  nuBASIC:
    description: |-
      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.
    links: {Website: https://nubasic.sourceforge.net/}
    source:
      Ext: [.nbas]
      Like: VBA-like
  NuGet Config:
    description: |-
      An XML configuration format used by the NuGet package management system to
      control package sources, dependency resolution behavior, and client
      settings across development environments.
    links: {Reference: https://learn.microsoft.com/en-us/nuget/reference/nuget-config-file, Repository: https://github.com/NuGet/NuGet.Client}
    source:
      Ext: [.config]
      Like: XML-like
      Fl: xcfg
  Nushell:
    description: |-
      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.
    links: {Reference: https://www.nushell.sh/book/}
    source:
      Ext: [.nu]
      Str: [['`', '`', ml], ['"', '"', ml|bse], ["'", "'", ml]]
      Co: ['for ', 'do { ', 'each {', 'if ', '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
  Nushell Object Notation:
    description: |-
      Nushell Object Notation is a data serialization format used by the
      Nushell project to represent structured data such as records, lists,
      and tables. It is designed to align with Nushell's internal data model
      and is used for configuration and data interchange within the shell
      environment.
    links: {Reference: https://www.nushell.sh/book/nuon.html, Repository: https://github.com/nushell/nushell}
    source:
      Ext: [.nuon]
      Like: JSON-like
      Fl: xser
  NuSpec:
    description: |-
      NuSpec is an XML-based manifest format used to define metadata and packaging
      instructions for software distribution units in the .NET ecosystem. It
      encapsulates descriptive information, dependency declarations, and packaging
      rules, serving as the authoritative specification from which distributable
      artifacts are constructed.
    links: {Website: https://learn.microsoft.com/en-us/nuget/reference/nuspec, Reference: https://learn.microsoft.com/en-us/nuget/reference/nuspec, Repository: https://github.com/NuGet/NuGet.Client}
    source:
      Ext: [.nuspec]
      Like: XML-like
      Fl: xbld
  Oberon:
    description: |-
      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.
    links: {Website: https://people.inf.ethz.ch/wirth/Oberon/}
    source:
      Ext: [.ob, .ob2]
      Like: Pascal-like
      St: ;
      Fl: xdead
  OCaml:
    description: |-
      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.
    links: {Reference: https://ocaml.org/docs}
    source:
      Ext: [.mli]
      Like: ML-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Odin:
    description: |-
      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.
    links: {Introduction: https://odin-lang.org/docs/overview/}
    source:
      Ext: [.odin]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'when ', 'switch ', 'defer ', 'else ', '|| ', '&& ', '!= ', '== ']
  Ohm:
    description: |-
      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.
    links: {Website: https://ohmjs.org/}
    source:
      Ext: [.ohm]
      Fl: xpld
      Bc: [[//, "\n"]]
  Opalang:
    description: |-
      Opalang is a functional programming language designed for building
      complete web applications in a single unified environment covering
      server logic, client code, and database interaction. Programs are
      written as modules containing function definitions, type declarations,
      and pattern-matching expressions, and the language supports
      higher-order functions, algebraic data types, and parametric
      polymorphism. The same source program can contain code that runs on
      the server and code that executes in the browser, with the compiler
      partitioning the program automatically and generating the necessary
      JavaScript and server components. The language also integrates
      database queries and web services directly into the programming model
      so that web interfaces, application logic, and persistent storage can
      be developed as a single coherent program.
    links: {Website: https://opalang.org, Repository: https://github.com/opalang/opalang}
    source:
      Ext: [.opa]
      Like: Pascal-like
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  OpenAPI:
    description: |-
      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.
    links: {Website: https://spec.openapis.org/}
    source:
      Ext: [.openapi]
      Fl: xidl
      Bc: [['#', "\n"]]
  OpenCL:
    description: |-
      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.
    links: {Reference: https://registry.khronos.org/OpenCL/specs/}
    source:
      Ext: [.ol, .clcpp]
      Like: C-like
      St: ;
      Fl: xcpp
  OpenSCAD:
    description: |-
      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.
    links: {Reference: https://openscad.org/documentation.html}
    source:
      Ext: [.scad]
      Like: C-like
      Str: [['"', '"']]
      Fl: xmdl
  OpenTofu:
    description: |-
      Following Terraform's move to an OSD-conformant license, the project
      was formed as OpenTofu. OpenTofu interprets Terraform declaration
      files, but looks for files with extension ,tofu first; these files may
      be written in an extended version of the HCL/Terraform configuration
      language.
    links: {Website: https://opentofu.org, Repository: https://github.com/opentofu/opentofu}
    source:
      Ext: [.tofu]
      Like: HCL
      Co: [count, for, for_each, if, ': ', '? ', '|| ', '&& ', '!= ', '> ', '>= ', '< ', '<= ', '== ']
  OpenType:
    description: |-
      OpenType Feature Files (".fea") are a DSL for defining OpenType layout
      behavior such as GSUB/GPOS substitutions and positioning.
    links: {Reference: https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html}
    source:
      Ext: [.fea]
      Str: [['"', '"']]
      Fl: xdsl
      Bc: [['#', "\n"]]
  Org:
    description: |-
      Org mode is a plain-text outlining and authoring format used mainly
      in Emacs for notes, documents, and literate workflows.
    links: {Reference: https://orgmode.org/manual/}
    source:
      Ext: [.org]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: doc
      Bc: [['#', "\n", sol]]
  Oz:
    description: |-
      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.
    links: {Website: https://mozart.github.io/}
    source:
      Ext: [.oz]
      Str: [['"', '"', bse|ml], ['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['%', "\n"]]
  P4:
    description: |-
      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.
    links: {Website: https://p4.org/}
    source:
      Ext: [.p4]
      Like: C-like
      St: ;
      Str: [['"', '"']]
      Fl: xcpp|xdsl
  PacmanMakepkg:
    description: |-
      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".
    links: {Reference: https://man.archlinux.org/man/PKGBUILD.5}
    source:
      Files: [PKGBUILD]
      Str: [['"', '"', ml|bse]]
      Fl: xbld
      Bc: [['#', "\n"]]
  PAL:
    description: |-
      PAL was an extremely obscure academic language.  RPAL was a
      pure-functional subset of PAL.  Both used the same lexical
      syntax. It is very dead, but supported for historical reasons.
    links: {PAL paper: https://dl.acm.org/doi/10.1145/800186.810604}
    source:
      Ext: [.pal]
      Str: [["'", "'"]]
      Fl: xdead
      Bc: [[//, "\n"]]
  patch:
    description: |-
      patch refers to patch-file syntax consumed by tools such as `patch` and
      `git apply`. Like diff, it is a change-description format rather than a
      source programming language.
    links: {Reference: https://www.gnu.org/software/diffutils/manual/html_node/patch-Input.html}
    source:
      Ext: [.patch]
      Fl: xdsl
  Pawn:
    description: |-
      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.
      Development has ben discontinued.
    links: {Reference: https://github.com/compuphase/pawn}
    source:
      Ext: [.pwn]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
      Fl: xdead
  Pek:
    description: |-
      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.
    links: {Website: https://www.gnu.org/software/poke/}
    source:
      Ext: [.pek]
      Like: C-like
      St: ;
      Fl: xdsl
  Peggy:
    description: |-
      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.
    links: {Website: https://peggyjs.org/}
    source:
      Ext: [.peggy]
      Like: C-like
      Str: [["'", "'"]]
      Fl: xpld
  PEG.js:
    description: |-
      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.
    links: {Website: https://pegjs.org/}
    source:
      Ext: [.pegjs]
      Like: C-like
      Str: [['"', '"']]
      Fl: xpld
  Pest:
    description: |-
      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.
    links: {Website: https://pest.rs/}
    source:
      Ext: [.pest]
      Str: [['"', '"']]
      Fl: xpld
      Bc: [[//, "\n"]]
  pic:
    description: |-
      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.
    links: {Manual page: https://man7.org/linux/man-pages/man1/pic.1.html, Reference: https://pikchr.org/home/uv/gpic.pdf}
    source:
      Ext: [.pic]
      Str: [['"', '"', bse|ml], ['"', '"', bse]]
      Fl: xmdl
      Bc: [['#', "\n"]]
  Pig Latin:
    description: |-
      Pig Latin is a dataflow scripting language used by Apache Pig for
      processing large datasets in distributed environments. It expresses
      data transformations as sequences of operations on relations, which
      are compiled into execution plans for systems such as Hadoop
      MapReduce, Tez, or Spark.
    links: {Reference: https://pig.apache.org/docs/latest/basic.html, Repository: https://github.com/apache/pig}
    source:
      Ext: [.pig]
      Str: [['"', '"', ml], ["'", "'", ml]]
      Bc: [[--, "\n"]]
      Fl: xqry
  Pike:
    description: |-
      Pike is a dynamically typed, object-oriented programming language with
      a syntax similar to C, C++, C#, and Java. It is interpreted, garbage
      collected, and designed for rapid development of network services,
      text-processing tools, and other general-purpose applications while
      retaining familiar C-family declarations, control structures, and
      block syntax.
    links: {Reference: https://pike.lysator.liu.se/docs/man/, Repository: https://github.com/pikelang/Pike}
    source:
      Ext: [.pike, .pmod]
      She: [pike]
      Like: C-like
      St: ;
      Fl: xcpp
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'switch ', 'while ', 'do ', 'else ', 'catch ', '&& ', '|| ', '!= ', '== ']
  PKGBUILD:
    description: |-
      PKGBUILD is the build script format used by the Arch Linux packaging
      system to define how software packages are built, installed, and
      described for distribution through the pacman package manager. It
      encodes metadata, sources, dependencies, and build steps in a form
      processed by the makepkg tool.
    links: {Website: https://archlinux.org/, Reference: https://wiki.archlinux.org/title/PKGBUILD, Repository: https://gitlab.archlinux.org/pacman/pacman}
    source:
      Files: [PKGBUILD]
      Like: Shell-like
      Fl: xbld
  Pkl:
    description: |-
      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.
    links: {Reference: https://pkl-lang.org/main/current/language-reference/index.html}
    source:
      Ext: [.pkl]
      Bc: [[/*, '*/'], [//, "\n"], ['#', "\n"]]
      Str: [['"""', '"""', bse|ml], ['"', '"', bse]]
      Co: ['function ', '?? ', '?.', ifNonNull(, 'if ', ' else ', .map, 'for ', 'when ', '...']
      Fl: xcfg
  PlantUML:
    description: |-
      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.
    links: {Website: https://plantuml.com/}
    source:
      Ext: [.puml, .plantuml, .iuml]
      Bc: [[/*, '*/'], ["'", "\n"]]
      Fl: xmdl
  PL/1:
    description: |-
      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.
    links: {Reference: "https://www.ibm.com/docs/en/zos/latest?topic=pl1-language-reference"}
    source:
      Ext: [.pl1, .pli]
      Bc: [[/*, '*/']]
      St: ;
      Str: [["'", "'"]]
      Fl: xdead
  PL/M:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/PL/M}
    source:
      Ext: [.plm]
      Bc: [[/*, '*/']]
      St: ;
      Fl: xdead
  PlusCal:
    description: |-
      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.
    links: {Reference: https://lamport.azurewebsites.net/tla/book.html}
    source:
      Ext: [.pcal]
      Bc: [[(*, '*)']]
      St: ;
      Fl: xmdl
  PLYMesh:
    description: |-
      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.
    links: {Reference: https://paulbourke.net/dataformats/ply/}
    source:
      Ext: [.ply]
      Fl: xmdl
  PO:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html}
    source:
      Ext: [.po]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Bc: [['#', "\n"]]
  Poke:
    description: |-
      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".
    links: {Website: https://www.jemarch.net/poke}
    source:
      Ext: [.pk]
      Like: C-like
      Fl: xdsl
  POML:
    description: |-
      POML is a markup language designed for structuring prompts and related
      assets used in large language model applications. It provides a way to
      organize prompt text, variables, examples, and supporting data into
      reusable components that can be composed and processed by tooling
      before being sent to a model. Documents typically define sections
      representing system instructions, user prompts, contextual
      information, and structured data so that complex prompts can be
      assembled programmatically. The format is intended to help developers
      manage prompt templates, maintain consistency across applications, and
      integrate prompt construction into automated pipelines.
    links: {Reference: https://microsoft.github.io/poml/, Repository: https://github.com/microsoft/poml}
    source:
      Ext: [.poml]
      Like: XML-like
      Fl: xdsl
  Pony:
    description: |-
      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.
    links: {Cheat sheet: https://www.ponylang.io/media/cheatsheet/pony-cheat-sheet.pdf}
    source:
      Ext: [.pony]
      Str: [['"""', '"""', ml], ['"', '"']]
      Co: ['for ', 'if ', 'match ', repeat, 'while ', 'else ', 'elseif ', '| ', '|| ', '&& ', '!= ', '== ']
      Fl: xtsmc
      Bc: [[//, "\n"]]
  PostCSS:
    description: |-
      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.
    links: {Website: https://postcss.org/}
    source:
      Ext: [.pcss, .postcss]
      Bc: [[/*, '*/']]
      Str: [['"', '"']]
      Fl: xdsl
  PostScript:
    description: |-
      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.
    links: {Reference: https://www.adobe.com/content/dam/acom/en/devnet/actionscript/articles/PLRM.pdf}
    source:
      Ext: [.ps]
      Co: [if, ifelse, for, repeat, loop, forall, pathforall, eq, ne, not, and, or]
      Bc: [['%', "\n"]]
  PowerShell:
    description: |-
      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.
    links: {PowerShell syntax: https://ss64.com/ps/syntax.html}
    source:
      Ext: [.ps1, .psm, .psm1]
      Bc: [[<#, '#>'], ['#', "\n"]]
      Str: [["@\"\n", '\n"@', ml], ["@'\n", "\n'@", ml], ['"', '"'], ["'", "'"]]
      Co: ['while ', while(, 'until ', until(, 'for ', for(, 'foreach ', foreach(, 'if ', 'elseif ', 'else ', switch, switch(, -gt, -lt, -eq, -ne, -ge, -le, -in, -notin, -contains, -notcontains]
  Praat:
    description: |-
      Praat is a speech-analysis and phonetics application with a built-in
      scripting language for automating menu commands, object operations,
      calculations, file processing, and acoustic-analysis workflows. Praat
      scripts combine command-style statements with variables, numeric and
      string expressions, conditionals, loops, procedures, forms, and calls
      to the Praat runtime, making them a common way to batch speech and
      annotation tasks in phonetics and linguistics research.
    links: {Website: https://praat.org/, Reference: https://praat.org/manual/Scripting.html}
    source:
      Ext: [.praat]
      She: [praat]
      Bc: [['#', "\n"], [;, "\n"]]
      Str: [['"', '"']]
      Sb: if|for|while|repeat|procedure|form|beginPause|editor
      Eb: endif|endfor|endwhile|until|endproc|endform|endPause|endeditor
      Co: ['if ', 'elsif ', 'elif ', 'else', 'for ', 'while ', 'repeat', 'until ', 'procedure ', 'form ', 'beginPause', 'editor ', 'and ', 'or ', '<> ', '= ']
      Fl: xaud
  Prisma:
    description: |-
      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.
    links: {Reference: https://www.prisma.io/docs/orm/prisma-schema}
    source:
      Ext: [.prisma]
      Like: C-like
      Fl: xcfg
  Processing:
    description: |-
      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.
    links: {Website: https://processing.org/, Reference: https://processing.org/reference/}
    source:
      Ext: [.pde]
      Like: C-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Properties File:
    description: |-
      The Properties File format is a line-oriented configuration format
      consisting of textual key–value assignments used primarily for
      application configuration and message catalogs.  The format is most
      widely associated with Java configuration and localization resources
      but has been adopted by many other tools that read or generate
      compatible files.
    links: {Reference: https://en.wikipedia.org/wiki/.properties}
    source:
      Ext: [.properties]
      Fl: xcfg
      Bc: [['#', "\n"]]
  PRQL:
    description: |-
      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.
    links: {Website: https://prql-lang.org/}
    source:
      Ext: [.prql]
      Str: [['"', '"', bse]]
      Co: ['case ', '&& ', '|| ', '!= ', '== ', '~= ']
      Fl: xqry
      Bc: [['#', "\n"]]
  ProGuard:
    description: |-
      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.
    links: {Reference: https://www.guardsquare.com/manual/configuration/usage}
    source:
      Ext: [.proguard, .proguardcfg]
      Fl: xcfg
      Bc: [['#', "\n"]]
  Promela:
    description: |-
      Promela is the modeling language used by the SPIN model checker to
      describe asynchronous concurrent systems, communication protocols, and
      distributed algorithms. A Promela model defines processes, channels,
      nondeterministic choices, assertions, temporal properties, and control
      flow that SPIN can simulate or exhaustively verify by exploring the
      reachable state space.
    links: {Reference: https://spinroot.com/spin/Man/promela.html, Website: https://spinroot.com/}
    source:
      Ext: [.pml]
      Bc: [[/*, '*/']]
      Str: [['"', '"', bse]]
      St: ;
      Fl: xcpp|xmdl
      Co: ['active ', 'proctype ', 'init ', 'never ', 'if ', 'fi', 'do ', 'od', 'atomic ', 'd_step ', 'unless ', 'assert ', 'run ', 'timeout', '::', '->', '&& ', '|| ', '!= ', '== ']
  PromQL:
    description: |-
      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.
    links: {Reference: https://prometheus.io/docs/prometheus/latest/querying/basics/}
    source:
      Ext: [.promql]
      Str: [['"', '"', bse]]
      Fl: xqry
      Bc: [['#', "\n"]]
  Protobuf:
    aka: ['Protocol Buffers']
    description: |-
      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.
    links: {Reference: https://protobuf.dev/reference/protobuf/proto3-spec/}
    source:
      Ext: [.proto]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  Pug:
    description: |-
      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.
    links: {Website: https://pugjs.org/}
    source:
      Ext: [.pug]
      Str: [['"', '"', bse]]
      Fl: xtpl
      Bc: [[//, "\n"]]
  Puppet:
    description: |-
      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.
    links: {Reference: https://www.puppet.com/docs/puppet/latest/lang_summary.html}
    source:
      Ext: [.pp]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcfg
      Bc: [['#', "\n"]]
  PureScript:
    description: |-
      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.
    links: {Website: https://www.purescript.org/}
    source:
      Ext: [.purs]
      Like: Haskell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Pyret:
    description: |-
      Pyret is an educational programming language designed for teaching
      data-centric programming and testing.
    links: {Reference: https://pyret.org/docs/latest/}
    source:
      Ext: [.arr, .pyret]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Bc: [['#', "\n"]]
  Q#:
    description: |-
      Q# is a programming language developed by Microsoft for expressing
      quantum algorithms and quantum programs. It is part of the Microsoft
      Quantum Development Kit and is designed to work with classical host
      programs while describing quantum operations, measurements, and
      transformations on qubits. Q# programs are typically compiled and
      executed using quantum simulators or quantum hardware through host
      environments such as .NET languages.
    links: {Reference: https://learn.microsoft.com/en-us/azure/quantum/user-guide/language/, Repository: https://github.com/microsoft/qsharp}
    source:
      Ext: [.qs]
      Like: C-like
      St: ;
      Bc: [[/*, '*/'], [//, "\n"]]
      Co: ['for ', for(, 'repeat ', 'repeat{', until (, until(, 'if ', if(, 'elif ', 'elif{', 'else ', 'else{', '||| ', '&&& ', <<<, '>>>', ^^^, ~~~, '!= ', '== ']
  QCL:
    description: |-
      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.
    links: {Reference: http://tph.tuwien.ac.at/~oemer/qcl.html}
    source:
      Ext: [.qcl]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
  QML:
    description: |-
      QML is a declarative UI language in the Qt framework, typically used
      to define interface structure and behavior.
    links: {Reference: https://doc.qt.io/qt-6/qtqml-index.html}
    source:
      Ext: [.qml]
      Like: C-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  Quarto:
    description: |-
      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.
    links: {Website: https://quarto.org/}
    source:
      Ext: [.qmd]
      Fl: doc|xdsl
  Ragel:
    description: |-
      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.
    links: {Reference: https://www.colm.net/open-source/ragel/}
    source:
      Ext: [.rl]
      Like: C-like
      Fl: xpld
  Rakefile:
    description: |-
      Rakefiles are Ruby-based build/task scripts used by Ruby's "rake" tool,
      typically in files named "Rakefile".
    links: {Website: https://ruby.github.io/rake/}
    source:
      Ext: [.rake]
      Files: [rake, rakefile]
      Like: Ruby-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
  RapydScript:
    description: |-
      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.
    links: {Website: https://rapydscript.com/}
    source:
      Ext: [.pyj]
      Like: JavaScript-like
  RAML:
    description: |-
      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.
    links: {Reference: https://github.com/raml-org/raml-spec}
    source:
      Ext: [.raml]
      Str: [['"', '"', bse]]
      Fl: xidl
      Bc: [['#', "\n"]]
  Rascal:
    description: |-
      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.
    links: {Website: https://www.rascal-mpl.org/}
    source:
      Ext: [.rsc]
      Like: C-like
      St: ;
      Fl: xtrn
  Razor:
    description: |-
      Razor is a server-side templating language used in ASP.NET for
      generating dynamic web pages. It allows markup to be combined with
      embedded code so that page content can be produced dynamically during
      request processing. Razor templates are commonly used in ASP.NET MVC
      and ASP.NET Core applications to render views, where the template is
      compiled and executed to produce HTML sent to the client browser.
    links: {Introduction: https://learn.microsoft.com/en-us/aspnet/core/mvc/views/razor, Repository: https://github.com/dotnet/aspnetcore/tree/main/src/Razor}
    source:
      Ext: [.cshtml, .vbhtml]
      Like: HTML
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  ReasonML:
    aka: [Reason]
    description: |-
      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,
    links: {Website: https://reasonml.github.io/}
    source:
      Ext: [.re, .rei]
      Like: ML-like
      Str: [['{|', '|}', ml]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[//, "\n"]]
  Reduce:
    description: |-
      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.
    links: {Website: https://reduce-algebra.sourceforge.io/}
    source:
      Ext: [.red]
      Bc: [[/*, '*/'], ['%', "\n"]]
      Str: [['"', '"', bse]]
      Fl: xmat
  REFAL:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/Refal}
    source:
      Ext: [.ref, .refal]
      Bc: [['*', "\n"]]
  Rego:
    aka: [Open Policy Agent]
    description: |-
      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.
    links: {Reference: https://openpolicyagent.org/docs/policy-language}
    source:
      Ext: [.rego]
      Str: [['"', '"']]
      Fl: xcfg
      Bc: [['#', "\n"]]
  reStructuredText:
    aka: [ReStructuredText, reST]
    description: |-
      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.
    links: {Reference: https://docutils.sourceforge.io/rst.html}
    source:
      Ext: [.rst, .rest]
      Fl: doc
      Bc: [[.., "\n", sol]]
  ReScript:
    description: |-
      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.
    links: {Reference: https://rescript-lang.org/docs/manual/latest/introduction}
    source:
      Ext: [.res, .resi]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', '=== ']
  Ren'Py:
    description: |-
      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.
    links: {Reference: https://www.renpy.org/doc/html/}
    source:
      Ext: [.rpy]
      Str: [['"""', '"""', bse|ml], ['"', '"', bse|ml], ["'", "'", ml], ['"', '"', bse]]
      Bc: [['#', "\n"]]
      Fl: xdsl
  RenderMan RIB:
    aka: [RIB]
    description: |-
      RenderMan RIB is the RenderMan Interface byte stream, a scene
      description format used to send rendering requests to
      RenderMan-compatible rendering systems. Text RIB files describe
      frames, worlds, camera settings, transformations, lights, shader
      assignments, attributes, geometric primitives, archives, and other
      rendering state as ordered request tokens with parameter lists.
    links: {Reference: https://www.fileformat.info/format/pixarrib/spec/b05849d487c04cc491fa605d64020e79/view.htm, Parser: https://renderman.pixar.com/resources/rman26/classRixRIBParser.html}
    source:
      Ext: [.rib]
      Str: [['"', '"', bse|ml]]
      Bc: [['#', "\n"]]
      Co: [FrameBegin, WorldBegin, AttributeBegin, TransformBegin, SolidBegin, ObjectBegin, MotionBegin, ReadArchive, Procedural, PointsPolygons, SubdivisionMesh, AreaLightSource, LightSource, Surface, Displacement]
      Fl: xmdl
  RDL:
    aka: Report Definition Language
    description: |-
      RDL (Report Definition Language) is an XML-based format used to describe the
      structure and layout of reports for Microsoft SQL Server Reporting
      Services (proprietary software, but RDL has an open public
      specification). A report definition specifies datasets, queries,
      parameters, visual elements, grouping, and formatting rules used to
      render tabular and graphical reports. The language is used by report
      designers and tooling to define reports that can be executed by a
      reporting server and rendered in formats such as HTML, PDF, or Excel.
    links: {Reference: https://learn.microsoft.com/en-us/sql/reporting-services/reports/report-definition-language-ssrs}
    source:
      Ext: [.rdl]
      Like: XML-like
      Fl: xdsl
  Relax/NG:
    aka: [RELAX NG]
    description: |-
      Relax/NG is a schema language for XML documents. The XML syntax uses
      vocabulary in the Relax NG namespace to describe allowed elements,
      attributes, datatypes, and structural relationships in document trees.
    links: {Website: https://relaxng.org/, Reference: https://relaxng.org/spec-20011203.html}
    source:
      Ext: [.rng]
      Like: XML-like
      Fl: xdsl
  Rexx:
    description: |-
      REXX (Restructured Extended Executor) is a scripting and macro
      language originally developed at IBM for use on mainframes.  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, where it fills a role similar to shell scripting under Unix.
    links: {Website: https://www.oorexx.org/}
    source:
      Ext: [.rexx, .rex]
      Bc: [[/*, '*/']]
  Rhai:
    description: |-
      Rhai is a lightweight embedded scripting language designed for
      integration into Rust applications, providing a safe and flexible way
      to extend program behavior at runtime. It emphasizes ease of
      embedding, minimal footprint, and sandboxed execution, making it
      suitable for configuration, automation, and user-defined logic within
      host programs.
    links: {Reference: https://rhai.rs/book/, Repository: https://github.com/rhaiscript/rhai}
    source:
      Ext: [.rhai]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", ml|bse]]
  Ring:
    description: |-
      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.
    links: {Website: https://ring-lang.github.io/}
    source:
      Ext: [.ring]
      Str: [['"', '"', bse]]
      Bc: [['#', "\n"]]
  RMarkdown:
    description: |-
      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.
    links: {Website: https://rmarkdown.rstudio.com/}
    source:
      Ext: [.Rmd]
      Fl: doc|xdsl
  Robot Framework:
    description: |-
      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.
    links: {Website: https://robotframework.org/}
    source:
      Ext: [.robot, .resource]
      Fl: xtst
      Bc: [['#', "\n"]]
  Roc:
    description: |-
      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.
    links: {Website: https://www.roc-lang.org/, Introduction: https://www.roc-lang.org/tutorial, Repository: https://github.com/roc-lang/roc}
    source:
      Ext: [.roc]
      Str: [['"""', '"""', bse|ml], ['"', '"', bse|ml], ['"', '"', bse]]
      Bc: [['#', "\n"]]
  RON:
    description: |-
      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.
    links: {Reference: https://github.com/ron-rs/ron}
    source:
      Ext: [.ron]
      Like: C-like
      Str: [['"', '"']]
      Fl: xser
  RPAL:
    description: |-
      RPAL was a pure-functional subset of PAL.  Both used the same lexical
      syntax. It is very dead, but supported for historical reasons.
    links: {RPAL reference manual: https://rpal.sourceforge.net/}
    source:
      Ext: [.rpal]
      Like: PAL
      Fl: xdead
  RPG:
    description: |-
      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.
    links: {Reference: "https://www.ibm.com/docs/en/i/7.5?topic=languages-rpg"}
    source:
      Ext: [.rpg, .rpgle, .sqlrpgle]
      Fl: xprop
      Bc: [[//, "\n"]]
  RPMSpecfile:
    description: |-
      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.
    links: {Reference: https://rpm.org/docs/latest/manual/spec.html}
    source:
      Ext: [.spec]
      Fl: xbld
      Bc: [['#', "\n"]]
  RTF:
    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.
    links: {Reference: https://en.wikipedia.org/wiki/Rich_Text_Format}
    source:
      Ext: [.rtf]
      Bc: [['{\*', '}']]
      Fl: doc
  Ruby:
    description: |-
      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.
    links: {Website: https://ruby-lang.org/}
    source:
      Ext: [.rb]
      She: [ruby]
      Like: Ruby-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Rust:
    description: |-
      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.
    links: {Reference: https://doc.rust-lang.org/reference/}
    source:
      Ext: [.rs]
      Bc: [[/*, '*/', cnest], [//, "\n"]]
      St: ;
      Str: [['(?:b|c)?r(#{0,255})"', '"&', ml|re], ['"', '"', ml|bse]]
      Co: ['for ', for(, 'if ', if(, 'while ', while(, 'loop ', 'loop{', 'else ', 'else{', '|| ', '&& ', '!= ', '== ', 'match ', match(]
  SageMath:
    description: |-
      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.
    links: {Website: https://www.sagemath.org/}
    source:
      Ext: [.sage]
      Str: [['"', '"', bse]]
      Fl: xmat
      Bc: [['#', "\n"]]
  SAS:
    description: |-
      A proprietary statistical programming language and application environment used
      for data management, analysis, reporting, and regulated enterprise
      analytics, especially in finance, healthcare, and government settings.
    links: {Website: https://www.sas.com/en_us/software/sas9.html}
    source:
      Ext: [.sas]
      Bc: [['/*', '*/'], ['*', "\n"]]
      St: ';'
      Str: [['"', '"'], ['''', '''']]
      Co: ['do', '%do', 'if', '%if', 'else', '%else', 'case', 'or', 'and', '^=', '¬=', '~=', 'ne', 'eq']
      Fl: xprop
  Sass:
    description: |-
      Sass is a CSS preprocessor language, with both indented ".sass"
      syntax and CSS-like ".scss" syntax.
    links: {Reference: https://sass-lang.com/documentation/}
    source:
      Ext: [.sass]
      Bc: [[/*, '*/'], [//, "\n"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
  Scilab:
    description: |-
      Scilab is an open-source numerical-computing environment and
      programming language for matrix-oriented computation, simulation,
      signal processing, control systems, and scientific visualization. Its
      language is used for scripts and functions that manipulate numerical
      arrays, call built-in mathematical routines, and automate interactive
      computational workflows in a style similar to MATLAB and Octave.
    links: {Website: https://www.scilab.org/, Reference: https://help.scilab.org/docs}
    source:
      Ext: [.sci, .sce, .tst]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"'], ["'", "'"]]
      St: ;
      Sb: if|for|while|select|try|function
      Eb: end|endfunction
      Fl: xssep|xmat
      Co: ['for ', 'if ', 'elseif ', 'else ', 'select ', 'case ', 'while ', 'try ', 'catch ', 'then ', 'do ', '== ', '<> ', '~= ', '& ', '| ']
  sed:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/sed/manual/}
    source:
      Ext: [.sed]
      She: [sed]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', 'and ', 'or ', 'not ', 'in ']
      Bc: [['#', "\n"]]
  SCons:
    aka: [Scons]
    description: |-
      SCons is a software construction tool written in Python.  Build
      descriptions are written as Python scripts that specify targets,
      dependencies, and build actions.
    links: {Website: https://scons.org/}
    source:
      Files: [SConstruct, SConscript]
      She: [scons]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
      Fl: xbld
  SCSS:
    description: |-
      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.
    links: {Reference: https://sass-lang.com/documentation}
    source:
      Ext: [.scss]
      Bc: [[/*, '*/'], [//, "\n"]]
      Fl: xdsl
  SIL:
    description: |-
      Swift Intermediate Language (SIL) is a high-level, SSA-form
      intermediate representation (IR) designed specifically to
      implement the Swift programming language, bridging the gap
      between the Swift Abstract Syntax Tree (AST) and LLVM IR. Unlike
      LLVM IR, SIL captures language-specific type information,
      enabling high-level optimizations such as automatic reference
      counting (ARC), devirtualization, and generic specialization
      that are difficult to perform on lower-level Intermediate
      representations.
    links: {Reference: https://apple-swift.readthedocs.io/en/latest/SIL.html}
    source:
      Ext: [.sil]
      Like: "C-like"
      Fl: xirf
  Smithy:
    description: |-
      Smithy is an interface-definition language for modeling services,
      resources, operations, and data shapes in a protocol-agnostic way.
      Smithy models are used for validation, documentation, and code
      generation across SDKs and service frameworks.
    links: {Reference: https://smithy.io/2.0/spec/idl.html}
    source:
      Ext: [.smithy]
      Like: C-like
      Fl: xidl
  Snakemake:
    description: |-
      Snakemake is a workflow DSL for reproducible data-processing pipelines,
      built on Python syntax with rule-oriented constructs.
    links: {Website: https://snakemake.readthedocs.io/}
    source:
      Ext: [.smk]
      Files: [snakefile]
      Like: Python-like
      Co: ['for ', for(, 'while ', while(, 'if ', if(, 'elif ', elif(, 'else ', 'else:', 'match ', match(, 'try ', 'try:', 'except ', except(, 'finally ', 'finally:', 'with ', with (, 'and ', and(, 'or ', or(]
      Fl: xdsl
  Seed7:
    description: |-
      Seed7 is a general-purpose programming language designed to be easy to
      extend with user-defined statements and operators.
    links: {Reference: https://seed7.sourceforge.net/}
    source:
      Ext: [.sd7, .s7i]
      Like: Pascal-like
      St: ;
      Str: [['"', '"', bse]]
      Co: ['for ', 'if ', 'elsif ', else, 'else ', 'case ', 'while ', 'until ', 'catch ', 'or ', 'and ', '<> ', '= ']
      Bc: [['#', "\n"]]
  Self:
    description: |-
      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.
    links: {Website: https://selflanguage.org/}
    source:
      Ext: [.self]
      Bc: [['"', '"']]
      Str: [["'", "'"]]
  SETL:
    description: |-
      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.
    links: {Website: https://setl.org/}
    source:
      Ext: [.setl]
      St: ;
      Str: [["'", "'"]]
      Fl: xdead
      Bc: [[$, "\n"]]
  SGML:
    description: |-
      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.
    links: {Website: https://www.w3.org/MarkUp/SGML/}
    source:
      Ext: [.sgml]
      Like: XML-like
      Fl: doc
  sh:
    description: |-
      The Unix shell scripting language family (including sh, and dash)
      provides command execution and control-flow constructs for automating
      Unix system tasks. The ".sh" extension is generic to all of these; the
      bash and ksh have their own entries mainly to capture the variant
      extensions they use for startup and shutdown command files.
    links: {Reference: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html}
    source:
      Ext: [.sh, .dash, .profile]
      She: [sh]
      Like: Shell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Sieve:
    description: |-
      Sieve is a declarative mail filtering language used by mail delivery
      agents to process incoming messages according to user-defined
      rules. Scripts consist of commands and tests that evaluate message
      properties such as headers, addresses, and message size. Conditionals
      are available, and tests may be combined using logical operator. Core
      actions include delivering a message to a mailbox, forwarding, keep to
      retain the message in the default mailbox, and discard to silently
      drop it. The language also supports optional extensions that introduce
      additional tests and actions, enabled through require declarations
      placed near the beginning of a script.
    links: {Reference: https://datatracker.ietf.org/doc/html/rfc5228, Repository: https://github.com/cyrusimap/libsieve}
    source:
      Ext: [.sieve]
      Str: [['"', '"', bse]]
      Co: [if, 'if ', elsif, 'elsif ', allof, 'allof ', anyof, 'anyof ', allof(, anyof(]
      Bc: [['#', "\n"]]
      Fl: xcfg
  Simula:
    description: |-
      Simula is a programming language developed in Norway in the 1960s and
      is widely considered the first object-oriented programming language.
    links: {Website: https://www.simula.no/}
    source:
      Ext: [.sim]
      Bc: [["comment\n", ;], [comment, "\n"]]
      St: ;
      Str: [['"', '"', ml]]
      Fl: xdead
  SiSU:
    description: |-
      A document markup and publishing system designed to produce multiple
      output formats from a single source, supporting workflows that
      generate HTML, PDF, EPUB, and other representations from structured
      text.
    links: {Website: https://www.jus.uio.no/sisu/, Repository: https://git.sisudoc.org/projects/sisu}
    source:
      Ext: [.sst, .ssm, .ssi]
      Like: Markdown
      Fl: doc
  Skew:
    description: |-
      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.
    links: {Language reference: https://evanw.github.io/skew-lang.org/}
    source:
      Ext: [.sk]
      Str: [['"', '"', ml|bse]]
      Bc: [['#', "\n"]]
  Slang:
    description: |-
      Slang is a shading language designed for graphics programming that
      extends the syntax and capabilities of existing shader languages to
      support modular development and code reuse. Programs define shader
      stages and related functions used by graphics pipelines to process
      vertices, fragments, and other rendering data. The language provides
      facilities for generics, modules, and interface-based programming so
      that shader code can be written in a more composable and reusable
      style than traditional shader languages. A Slang compiler can
      translate programs to several backend shader formats used by modern
      graphics APIs, allowing the same shader source to target multiple
      rendering systems.
    links: {Website: https://shader-slang.com, Repository: https://github.com/shader-slang/slang}
    source:
      Ext: [.slang]
      Like: C-like
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xshd
  Slim:
    description: |-
      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.
    links: {Website: https://slim-template.github.io/, Repository: https://github.com/slim-template/slim}
    source:
      Ext: [.slim]
      Fl: xtpl
      Bc: [[/, "\n", sol]]
  Slint:
    description: |-
      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.
    links: {Website: https://slint.dev/}
    source:
      Ext: [.slint]
      Like: C-like
      Co: ['for ', 'if ', if(, 'states ', 'states[', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  Smalltalk:
    description: |-
      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.
    links: {User's Guide: https://www.gnu.org/software/smalltalk/manual/html_node/Tutorial.html}
    source:
      Ext: [.st]
      Co: ['bitAnd ', 'bitOr ', 'bitXor ', 'bitInvert ', 'bitShift ', 'bitAt ', 'highbit ', 'allMask ', 'anyMask ', 'noMask ', 'ifTrue ', 'ifFalse ', 'switch ', 'whileTrue ', 'whileFalse ', 'to: ']
      Bc: [['"', "\n"]]
  SMT-LIB:
    aka: [SMT2, 'Satisfiability Modulo Theories Library']
    description: |-
      SMT-LIB is the standard command and benchmark language for SMT
      solvers. SMT-LIB scripts use parenthesized commands to declare sorts
      and functions, choose a logic, assert formulas, request solver
      checks, models, values, proofs, and unsatisfiable cores, and describe
      benchmark problems over standard theories such as arithmetic, arrays,
      bit-vectors, and strings.
    links: {Website: https://smt-lib.org/, Reference: https://smt-lib.org/language.shtml, Examples: https://smt-lib.org/examples.shtml}
    source:
      Ext: [.smt2, .smt]
      Bc: [[;, "\n"]]
      Str: [['"', '"', bse], ['|', '|', bse]]
      Co: ['(assert ', '(check-sat', '(forall ', '(exists ', '(ite ', '(and ', '(or ', '(not ']
      Fl: xmat
  SNOBOL4:
    description: |-
      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
    links: {Website: https://www.snobol4.org/}
    source:
      Ext: [.sno]
      Str: [['"', '"']]
      Co: [':(', ':s(', ':f(', 'eq ', 'ne ']
      Bc: [['*', "\n", sol]]
  Snort:
    description: |-
      Snort is a rule language used to define network intrusion detection
      and prevention signatures for the Snort security engine. Rules specify
      patterns and conditions that identify suspicious or malicious activity
      in network traffic, including protocol characteristics, payload
      content, and behavioral indicators associated with attacks. Each rule
      describes the type of traffic to inspect, the matching criteria to
      apply, and the action to take when a match occurs, such as generating
      an alert or logging the event. Rule files are evaluated by the Snort
      engine as packets are analyzed so that known threats and policy
      violations can be detected in real time.

      The closely related Suricata language is also reported as Snort.
    links: {Website: https://www.snort.org, Repository: https://github.com/snort3/snort3}
    source:
      Ext: [.rules]
      Str: [['"', '"', bse]]
      Fl: xcfg
      Bc: [['#', "\n"]]
  Soong:
    description: |-
      Soong is one of Android's build systems and uses Android.bp files to
      describe modules, properties, source lists, dependencies, namespaces,
      and generated build artifacts. Android.bp files are declarative
      build descriptions processed by Soong, with complex build behavior
      implemented in Go rather than embedded control flow.
    links: {Reference: https://source.android.com/docs/setup/reference/androidbp, Repository: https://android.googlesource.com/platform/build/soong/}
    source:
      Files: [Android.bp]
      Bc: [['/*', '*/'], ['//', "\n"]]
      Str: [['"', '"', bse]]
      Fl: xbld
  Solidity:
    description: |-
      Solidity is a programming language for writing smart contracts that
      run on the Ethereum blockchain.
    links: {Website: https://docs.soliditylang.org/}
    source:
      Ext: [.sol]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', 'assembly ', 'assembly{', 'unchecked ', 'unchecked{']
      Fl: xctr
  SPARQL:
    aka: ['SPARQL Protocol and RDF Query Language']
    description: |-
      SPARQL is a query language for RDF graphs. SPARQL files define
      prefixes, graph patterns, filters, optional matches, aggregations,
      and result forms such as select, construct, ask, and describe queries.
    links: {Reference: https://www.w3.org/TR/sparql12-query/, Specification: https://w3c.github.io/sparql-query/spec/, Examples: https://www.w3.org/TR/sparql12-query/#examples}
    source:
      Ext: [.rq, .sparql]
      Bc: [['#', "\n"]]
      Str: [['"""', '"""', ml|bse], ["'''", "'''", ml|bse], ['"', '"', bse], ["'", "'", bse]]
      Co: ['SELECT ', 'select ', 'WHERE ', 'where ', 'FILTER ', 'filter ', 'OPTIONAL ', 'optional ', 'UNION ', 'union ', 'SERVICE ', 'service ', 'BIND ', 'bind ', 'MINUS ', 'minus ', 'GRAPH ', 'graph ']
      Fl: xqry
  SPDX:
    description: |-
      SPDX is a standardized format for representing software bill of
      materials (SBOM) data, including package inventories, licensing,
      copyright, and relationships between software components. It is used
      in compliance, security, and supply-chain transparency workflows to
      exchange structured metadata about software systems.
    links: {Website: https://spdx.dev/, Specification: https://spdx.github.io/spdx-spec/, Repository: https://github.com/spdx/spdx-spec}
    source:
      Ext: [.spdx, .spdx.json, .spdx.rdf]
      Fl: xser
  Spice:
    description: |-
      Spice is a systems programming language with C-family syntax (distinct
      from the circuit-simulator SPICE format above).
    links: {Website: https://spicelang.org/}
    source:
      Ext: [.spice]
      Like: C-like
      St: ;
  Squirrel:
    description: |-
      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.
    links: {Website: http://squirrel-lang.org/}
    source:
      Ext: [.nut]
      Like: C-like
      St: ;
      Str: [['"', '"']]
  SQL:
    description: |-
      SQL (Structured Query Language) is a declarative language used for
      managing and querying relational databases.
    links: {Reference: https://www.iso.org/standard/76583.html}
    source:
      Ext: [.sql]
      Like: SQL-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xqry
  SRecode:
    description: |-
      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.
    links: {Reference: https://www.gnu.org/software/emacs/manual/html_node/srecode/}
    source:
      Ext: [.srt]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtrn
      Bc: [['#', "\n"]]
  Stan:
    description: |-
      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.
    links: {Website: https://mc-stan.org/}
    source:
      Ext: [.stan]
      Like: C-like
      Fl: xdsl
  Stratego:
    description: |-
      Stratego is a rule-based program-transformation DSL, commonly used in
      the Spoofax language-workbench ecosystem.
    links: {Reference: https://spoofax.dev/references/stratego/}
    source:
      Ext: [.str]
      Like: C-like
      Fl: xtrn
  Stylus:
    description: |-
      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.
    links: {Website: https://stylus-lang.com/}
    source:
      Ext: [.styl]
      Bc: [[/*, '*/'], [//, "\n"]]
      Co: ['for ', 'if ', 'unless ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
  SubversionDump:
    description: |-
      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".
    links: {Reference: https://subversion.apache.org/docs/}
    source:
      Ext: [.svndump, .dump]
      Fl: xser
  SugarSS:
    description: |-
      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.
    links: {Reference: https://github.com/postcss/sugarss}
    source:
      Ext: [.sss]
      Like: C-like
      Str: [['"', '"']]
      Fl: xdsl
      Bc: [[//, "\n"]]
  SuperCollider:
    aka: [sclang]
    description: |-
      SuperCollider is a programming language and environment for real-time
      audio synthesis, algorithmic composition, live coding, and sound
      research. The language is dynamically typed, object-oriented, and
      functional, with syntax combining Smalltalk-style message passing,
      C-like block punctuation, first-class functions, pattern libraries, and
      literal notations for arrays, events, symbols, and signal-processing
      graph definitions. SuperCollider source commonly appears as class files
      and interactive documents evaluated by the sclang interpreter, often in
      coordination with the scsynth audio server.
    links: {Website: https://supercollider.github.io/, Reference: https://doc.sccode.org/Reference/Literals.html, Comments: https://doc.sccode.org/Reference/Comments.html}
    source:
      Ext: [.sc, .scd]
      Bc: [[/*, '*/', cnest], [//, "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", bse]]
      St: ;
      Co: ['if ', if(, 'while ', while(, 'for ', for(, 'case ', 'switch ', '.do', '.collect', '.select', '.reject', '.detect', '&& ', '|| ', '!= ', '== ', '=== ']
      Fl: xaud
  Svelte:
    description: |-
      Svelte is a component-oriented frontend DSL that compiles declarative
      components into JavaScript/CSS.
    links: {Reference: https://svelte.dev/docs/svelte/overview}
    source:
      Ext: [.svelte]
      Bc: [["<!--", "-->"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  SVG:
    description: |-
      SVG (Scalable Vector Graphics) is an XML-based language for describing
      two-dimensional vector graphics.
    links: {Reference: https://www.w3.org/TR/SVG2/}
    source:
      Ext: [.svg]
      Like: XML-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: doc
  SurrealQL:
    description: |-
      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.
    links: {Reference: https://surrealdb.com/docs/surrealql}
    source:
      Ext: [.surql]
      Like: SQL-like
      Fl: xqry
  SystemVerilog:
    description: |-
      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.
    links: {Reference: https://www.accellera.org/downloads/standards/systemverilog}
    source:
      Ext: [.sv, .svh]
      Bc: [[/*, '*/'], [//, "\n"]]
      St: ;
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '| ', '& ', '!= ', '!== ', '== ', 'foreach ', foreach(, 'case ', case(, 'casex ', casex(, 'casez ', casez(, 'casexz ', casexz(, 'fork ', ' ? ', inside, with, 'event ']
      Fl: xhdl
  TableGen:
    description: |-
      TableGen is a domain-specific language used in the LLVM project to
      describe target architectures, instruction sets, register files, and
      related compiler metadata. It provides a declarative way to generate
      compiler components such as assemblers and code generators, with
      definitions processed by the TableGen tool to produce C++ code and
      other artifacts.
    links: {HTML Documentation: https://llvm.org/docs/TableGen/index.html, Repository: https://github.com/llvm/llvm-project}
    source:
      Ext: [.td]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', ml], ["'", "'", ml]]
      Fl: xtrn
  Tact:
    description: |-
      Tact is a smart-contract programming language used in the TON
      blockchain ecosystem. Source files define contracts that encapsulate
      persistent storage, message handlers, and internal helper
      functions. Contracts declare storage fields directly within the
      contract body and provide handlers such as init for initialization and
      receive blocks that react to incoming messages. Functions are declared
      with fun and may return values or update contract state. The language
      supports user-defined message types, structured data types, and
      pattern-style matching of message payloads. Expressions include
      arithmetic, logical operations, and method calls, while built-in
      primitives interact with the TON runtime, allowing contracts to send
      messages, inspect transaction context, and manipulate serialized data
      cells used by the underlying blockchain system.
    links: {Website: https://tact-lang.org/, Documentation: https://docs.tact-lang.org/, Repository: https://github.com/tact-lang/tact}
    source:
      Ext: [.tact]
      Like: C-like
      Co: ['if ', if(, 'else ', 'try ', 'catch ', catch(, 'repeat ', repeat(, 'while ', while(, 'do ', 'until ', until(, 'foreach ', foreach(, '|| ', '&& ', '!= ', '== ']
      Fl: xctr
  Swift:
    description: |-
      Swift is a statically typed programming language developed by Apple
      for iOS, macOS, and other Apple platforms.
    links: {Reference: https://docs.swift.org/swift-book/}
    source:
      Ext: [.swift]
      Like: C-like
      Str: [['"""', '"""', ml], ['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', 'catch ', 'guard ', '?', '|| ', '&& ', '!= ', '== ']
  TaskPaper:
    description: |-
      TaskPaper is a plain-text outline format used for managing tasks,
      projects, and notes in a hierarchical structure. Documents are
      organized by indentation, where each line represents an item. Lines
      ending with a colon denote projects, lines beginning with a dash
      represent tasks, and all other lines are treated as notes. Metadata is
      attached using inline tags written with the at sign followed by a name
      and optional value in parentheses, such as
      @due(2026-03-15). Indentation determines parent–child relationships
      between items, allowing projects to contain tasks, notes, and nested
      projects. The format is designed to remain readable and editable as
      ordinary text while allowing software to interpret structure and
      metadata.
    links: {Website: https://www.taskpaper.com/, Format Guide: https://www.taskpaper.com/guide/, Repository: https://github.com/danielpunkass/TaskPaper}
    source:
      Ext: [.taskpaper]
      Bc: [['#', "\n"]]
  TEAL:
    description: |-
      TEAL is a stack-based assembly-like language used to define smart
      contracts on the Algorand blockchain. It is executed by the Algorand
      Virtual Machine and is designed for deterministic, secure evaluation
      of transaction logic within blockchain operations.
    links: {Reference: https://developer.algorand.org/docs/get-details/dapps/avm/teal/, Repository: https://github.com/algorand/go-algorand}
    source:
      Ext: [.teal]
      Str: [['"', '"', ml]]
      Bc: [[//, "\n"]]
      Fl: xctr
  TemplateToolkit:
    description: |-
      Template Toolkit is a text templating system widely used in Perl-based
      applications for generating dynamic content such as HTML,
      configuration files, and reports. It provides a directive-based syntax
      embedded within text, supporting variable interpolation, control flow
      constructs, filters, and reusable components. Templates are processed
      by an engine that combines input data with template logic to produce
      output, enabling separation of presentation from application code. It
      is commonly used in web frameworks and content generation pipelines
      where flexible text rendering is required.
    links: {Website: https://template-toolkit.org, Reference: https://metacpan.org/pod/Template}
    source:
      Ext: [.tt, .tt2]
      Str: [['"', '"']]
      Co: ['[% BLOCK', '[% FILTER', '[% FOR', '[% FOREACH', '[% IF', '[% INCLUDE', '[% MACRO', '[% PROCESS', '[% SWITCH', '[% UNLESS', '[% WRAPPER']
      Bc: [['#', "\n"]]
      Fl: xtpl
  Tera:
    description: |-
      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.
    links: {Reference: https://keats.github.io/tera/docs/}
    source:
      Ext: [.tera]
      Like: XML-like
      Co: ['{% include ', '{% macro ', '{% block ', '{% extends ', '{% for ', '{% set ', '{% if ', '{% elif ', '{% else ']
      Fl: xtpl
  Texinfo:
    description: |-
      Texinfo is a documentation language used by GNU projects to generate
      online manuals and printed documentation.
    links: {Reference: https://www.gnu.org/software/texinfo/}
    source:
      Ext: [.texinfo, .texi]
      Bc: [['@ignore', '@end', sol], ['@c', "\n"]]
      Fl: doc
  text:
    description: |-
      Plain text; no assumptions about comments or other syntax.

      Before ".adoc" became established, ".txt" was used as an
      extension for AsciiDoc files.
    source:
      Ext: [.txt, .text]
      Fl: doc
  Textile:
    description: |-
      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.
    links: {Website: https://textile-lang.com/}
    source:
      Ext: [.textile]
      Fl: doc
      Bc: [['#', "\n"]]
  TextProto:
    description: |-
      TextProto is a human-readable text format used for representing
      Protocol Buffers messages. Instead of the binary encoding normally
      used for Protobuf data, the format expresses message fields as textual
      assignments so that structured data can be inspected, edited, and
      stored in source repositories. Documents describe message instances
      using field names, nested message blocks, and repeated values that
      correspond directly to the structure defined in a Protocol Buffers
      schema. The format is commonly used for configuration files, test
      data, and debugging output in systems that use Protocol Buffers for
      data serialization.
    links: {Reference: https://protobuf.dev/reference/protobuf/textformat-spec/, Repository: https://github.com/protocolbuffers/protobuf}
    source:
      Ext: [.textproto, .pbtxt]
      Fl: xcfg
      Bc: [['#', "\n"]]
  Templ:
    description: |-
      Templ is a template language designed for generating HTML from
      programs written in the Go ecosystem. Templates combine HTML markup
      with embedded expressions and control constructs so that dynamic
      content can be produced by ordinary Go code.

      Not to be confused with GoTemplate, which is part of the Go
      standard library use to perform both HTML and text templating
      using Handlebars-like embedding of Go code in the document.
    links: {Website: https://templ.guide/}
    source:
      Ext: [.templ]
      Like: C-like
      Co: ['if ', ' else ', 'switch ', 'case ', 'default:', 'for ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  Thrift:
    aka: ['Apache Thrift']
    description: |-
      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.
    links: {Reference: https://thrift.apache.org/docs/idl}
    source:
      Ext: [.thrift]
      Like: C-like
      Fl: xidl
      Bc: [['#', "\n"]]
  Titanium Style Sheet:
    description: |-
      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.
    links: {Reference: https://github.com/appcelerator/alloy}
    source:
      Ext: [.tss]
      Like: JSON-like
      Fl: xcfg|xtpl
  TLA+:
    description: |-
      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.
    links: {Reference: https://lamport.azurewebsites.net/tla/tla.html}
    source:
      Ext: [.tla]
      Bc: [[(*, '*)'], [\*, "\n"]]
      Str: [['"', '"']]
      Fl: xmdl
  TNDSL:
    description: |-
      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.
    links: {Repository: https://github.com/tndsl/tndsl}
    source:
      Ext: [.tndsl]
      Fl: xdsl
  Toit:
    description: |-
      Toit is an open-source, object-oriented programming language and
      runtime designed for Internet of Things and microcontroller
      development. Toit source files define libraries, classes, methods,
      functions, and executable applications using indentation-based block
      structure, colon-terminated declarations and control forms, optional
      type annotations, package imports, and high-level APIs intended for
      connected embedded devices.
    links: {Website: https://docs.toit.io/language, Syntax: https://docs.toit.io/language/syntax/, Repository: https://github.com/toitlang/toit}
    source:
      Ext: [.toit]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"""', '"""', ml], ['"', '"', bse], ["'", "'", bse]]
      Co: ['if ', 'if:', 'else:', 'for ', 'for:', 'while ', 'while:', 'try:', 'finally:', 'class ', 'abstract class ', 'static ', 'return ', 'break', 'continue', 'and ', 'or ', 'not ', '!= ', '== ']
  TOML:
    description: |-
      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.
    links: {Website: https://toml.io/}
    source:
      Ext: [.toml]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xser
      Bc: [['#', "\n"]]
  TOON:
    description: |-
      TOON (Token-Oriented Object Notation) is a recent, experimental
      data-serialization format proposed on the OpenAPI Initiative
      blog and designed primarily for LLM pipelines and
      token-efficient data exchange. It aims to represent structured
      data (like JSON) while minimizing punctuation overhead and
      improving readability for both humans and language model.
    links: {Repository: https://github.com/toon-format/toon, Specification: https://toonformat.dev/reference/spec.html}
    source:
      Ext: [.toon]
      Str: [['"', '"', bse]]
      Fl: xser
  TRAC:
    description: |-
      TRAC is a text-processing programming language created in the 1960s.
      It was designed as a language for manipulating strings and symbolic
      expressions and is historically notable as one of the earliest
      languages built around purely textual computation.
    links: {Introduction: https://en.wikipedia.org/wiki/TRAC_(programming_language)}
    source:
      Ext: [.trac]
      Str: [['"', '"']]
      Fl: xdead
  Turtle:
    aka: ['Terse RDF Triple Language']
    description: |-
      Turtle is a compact text syntax for RDF graphs. Turtle files serialize
      triples using web identifiers, prefixed names, blank nodes, literals,
      collections, and repeated subject or predicate shortcuts, making RDF
      data easier to read and write than line-oriented triples formats.
    links: {Reference: https://www.w3.org/TR/rdf12-turtle/, Specification: https://w3c.github.io/rdf-turtle/spec/}
    source:
      Ext: [.ttl]
      Bc: [['#', "\n"]]
      Str: [['"""', '"""', ml|bse], ["'''", "'''", ml|bse], ['"', '"', bse], ["'", "'", bse], ['<', '>']]
      Fl: xser
  tsPEG:
    aka: [tspeg]
    description: |-
      tsPEG is a PEG parser-generator grammar language for TypeScript. Grammar
      files define parsing-expression rules with assignment, ordered choice,
      repetition, lookahead operators, quoted regex literals, and optional
      embedded TypeScript code for headers and computed AST properties. The
      tsPEG tool consumes these grammars and generates typed TypeScript parser
      modules.
    links: {Repository: https://github.com/EoinDavey/tsPEG, Package: https://www.npmjs.com/package/tspeg}
    source:
      Ext: [.tspeg, .jspeg]
      Like: JavaScript-like
      Fl: xpld
  TSX:
    description: |-
      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.
    links: {Reference: https://www.typescriptlang.org/docs/handbook/jsx.html}
    source:
      Ext: [.tsx]
      Like: JavaScript-like
  Treetop:
    description: |-
      Treetop is a parsing-expression grammar (PEG) language and parser
      generator implemented for the Ruby platform.  Grammar files define
      syntactic rules that describe the structure of input text and are used
      to generate Ruby parser classes capable of recognizing and producing
      syntax trees for that grammar.
    links: {Reference: https://github.com/cjheath/treetop}
    source:
      Ext: [.treetop]
      Like: Ruby-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xpld
  TITAN Project File Information:
    description: |-
      TITAN Project File Information is a simple key-value metadata
      format used by the TITAN TTCN-3 toolchain to describe project
      configuration, file organization, and build-related parameters. The
      format is line-oriented and human-readable, consisting of unquoted
      keys and values separated by an equals sign, with optional comment
      lines. It is primarily used as an auxiliary project descriptor and can
      be regenerated or modified by tooling, making it closer to build
      metadata than core source.
    links: {Introduction: https://projects.eclipse.org/projects/tools.titan, Repository: https://gitlab.eclipse.org/eclipse/titan/titan.core}
    source:
      Ext: [.tpd]
      Like: XML-like
      Fl: xcfg
  TTCN-3:
    description: |-
      TTCN-3 (Testing and Test Control Notation) is a programming language used
      for defining automated test suites for communication protocols and
      distributed systems.  TTCN-3 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.
    links: {Reference: https://www.etsi.org/deliver/etsi_es/201800_201899/201873/}
    source:
      Ext: [.ttcn, .ttcn3]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'from ', 'if ', if(, 'select ', 'case ', 'while ', 'do ', 'goto ', 'stop ', 'break ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtst
  TXL:
    description: |-
      TXL is a special-purpose source transformation language used for
      parsing, analyzing, transforming, and generating programs and other
      structured text. A TXL program combines an extensible grammar for the
      input language with functional and rule-based transformations written
      as pattern/replacement rules. It is used for software reengineering,
      language prototyping, design recovery, clone detection, and other
      source-to-source transformation tasks.
    links: {Website: https://txl.ca/, Reference: https://research.cs.queensu.ca/TechReports/Reports/1993-355.pdf, Introduction: https://research.cs.queensu.ca/home/cordy/Papers/Cordy_TXL_SCP.pdf}
    source:
      Ext: [.txl]
      Bc: [['%', "\n"]]
      Str: [['"', '"']]
      Sb: define|function|rule|keys|compounds|comments|tokens
      Eb: end
      Co: ['define ', 'function ', 'rule ', 'replace ', 'match ', 'by', 'where ', 'construct ', 'deconstruct ', 'include ', 'keys', 'compounds', 'comments', 'tokens', 'repeat ', 'opt ', 'list ', 'skipping ', 'export ', 'import ']
      Fl: xtrn
  Twig:
    description: |-
      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.
    links: {Reference: https://twig.symfony.com/doc/}
    source:
      Ext: [.twig]
      Like: XML-like
      Co: ['{% for ', '{% if ', '{% else ', '{% elseif ']
      Fl: xtpl
  TypeScript Typings:
    description: |-
      TypeScript Typings are declaration files that describe the shape of
      code for the TypeScript type system without providing executable
      implementations. They are used to supply type information for
      JavaScript libraries or separately compiled modules, enabling static
      analysis, editor tooling, and type checking. These files consist of
      ambient declarations for variables, functions, classes, interfaces,
      and modules, allowing TypeScript to understand external code
      boundaries. They play a central role in ecosystem interoperability,
      especially when consuming untyped or third-party code.
    links: {Introduction: https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html, Repository: https://github.com/DefinitelyTyped/DefinitelyTyped}
    source:
      Ext: [.d.ts, .d.mts, .d.cts]
      Like: JavaScript-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '!== ', '== ', '=== ', 'case ', 'case(', '?.', '?? ', '??= ']
  TypeSpec:
    description: |-
      TypeSpec is a language for describing service contracts and APIs in a
      way that separates protocol details from core data and operation
      definitions. It enables authors to express intent once and project
      that intent into multiple target ecosystems such as REST, OpenAPI, or
      client SDKs. The language emphasizes composability through reusable
      definitions and annotation mechanisms, allowing cross-cutting concerns
      like versioning, authentication, and transport mapping to be layered
      without entangling the core model.

      Reference:
      https://typespec.io/

      Repository:
      https://github.com/microsoft/typespec
    source:
      Ext: [.tsp]
      Like: C-like
      St: ;
      Str: [['"', '"', bse], ["'", "'"]]
      Fl: xidl
  Typst:
    description: |-
      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.
    links: {Reference: https://typst.app/docs/}
    source:
      Ext: [.typ]
      Fl: doc|xdsl
      Bc: [[//, "\n"]]
  Terraform:
    description: |-
      Terraform is a declarative configuration language used to describe
      infrastructure resources and their relationships so that systems can
      be provisioned and maintained automatically. Configurations are
      organized into blocks that declare providers, resources, modules,
      variables, outputs, and data sources, and expressions allow values to
      be computed from other objects in the configuration.

      Terraform was originally open-source, but has shifted to a license
      that is not OSD-conformant. OpenTofu is a fork of the last non-closed
      version.
    links: {Reference: https://developer.hashicorp.com/terraform}
    base:
      Co: [count, for, for_each, if, ': ', '? ', '|| ', '&& ', '!= ', '> ', '>= ', '< ', '<= ', '== ']
    variants:
      native:
        Ext: [.tf, .tfvars]
        Like: HCL
      json:
        Ext: [.tf.json, .tfvars.json]
        Like: JSON-like
        Co: [count, for_each, '${', 'if ', '|| ', '&& ', '!= ', '> ', '>= ', '< ', '<= ', '== ']
        Fl: xcfg
  Umka:
    description: |-
      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.
    links: {Reference: https://github.com/vtereshkov/umka-lang}
    source:
      Ext: [.um]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
  Uiua:
    description: |-
      Uiua is a general-purpose, stack-based, array-oriented programming
      language with a strong emphasis on tacit code, compact symbolic
      notation, and whole-array transformation.  It belongs to the broad APL
      family of array languages, but is an actively developed modern design
      with an interpreter, language server, and browser-based pad.
    links: {Website: https://www.uiua.org/, Reference: https://docs.rs/uiua_parser/latest/src/uiua_parser/lex.rs.html, Repository: https://github.com/uiua-lang/uiua}
    source:
      Ext: [.ua]
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse], ['\\$\\$?(?: |$)', "\n", re]]
  Unison:
    description: |-
      Unison is a functional programming language with a content-addressed
      codebase and integrated tooling workflow.
    links: {Reference: https://www.unison-lang.org/docs/language-reference/}
    source:
      Ext: [.u]
      Like: Haskell-like
  Ur/Web:
    description: |-
      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.
    links: {Reference: https://www.impredicative.com/ur/manual.pdf}
    source:
      Ext: [.ur, .urs]
      Bc: [[(*, '*)', cnest]]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
  Ur/Web Project:
    description: |-
      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.
    links: {Reference: https://www.impredicative.com/ur/manual.pdf}
    source:
      Ext: [.urp]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [['#', "\n"]]
  Vala:
    description: |-
      Vala is a programming language designed to bring modern language
      features to the GNOME platform while compiling to C.
    links: {Reference: https://wiki.gnome.org/Projects/Vala}
    source:
      Ext: [.vala, .vapi]
      Like: C-like
      St: ;
      Str: [['"""', '"""', ml], ["'''", "'''", ml]]
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ']
  VBScript:
    description: |-
      VBScript is a lightweight scripting language derived from Visual Basic
      and used historically in Windows administration, Classic ASP, and
      Windows Script Host automation. Wine includes an open-source
      implementation.
    links: {Repository: https://github.com/wine-mirror/wine/tree/master/dlls/vbscript}
    source:
      Like: 'VBA-like'
      Ext: [.vbs, .vbe]
  VCL:
    description: |-
      VCL (Varnish Configuration Language) is the configuration language
      used by Varnish Cache to define how HTTP requests and responses are
      processed, routed, and cached. It is compiled into an intermediate
      form and executed by the Varnish runtime to control request handling
      behavior at different stages of the processing pipeline.
    links: {Website: https://varnish-cache.org/, Introduction: https://varnish-cache.org/docs/trunk/users-guide/vcl.html, Specification: https://varnish-cache.org/docs/trunk/reference/vcl.html, Repository: https://github.com/varnishcache/varnish-cache}
    source:
      Ext: [.vcl]
      Like: C-like
      Fl: xcfg
  VTC:
    description: |-
      Varnish Test Case (VTC) domain-specific testing language used by the
      Varnish Cache project to define reproducible scenarios for validating
      HTTP caching behavior, backend interactions, and protocol handling. It
      enables scripted orchestration of clients, servers, and proxy
      instances within controlled test environments.
    links: {Reference: https://varnish-cache.org/docs/trunk/reference/vtc.html, Repository: https://github.com/varnishcache/varnish-cache}
    source:
      Ext: [.vtc]
      Like: Shell-like
      Fl: xtst
  ignore:
    description: |-
      Several version-control systems have very similar names and syntaxes
      for a dotfile that declares which files or file patterns. This
      convention has been adopted by other tools, notably ripgrep(1),
      and is supported by a Rust crate with a syntax deliberately
      upward-compatible from .gitignore's. Such tools usually interpret
      .gitignore before .ignore.
    links: {Reference: https://docs.rs/ignore/latest/ignore/}
    source:
      Files: [.bzrignore, .fossilignore, .gitignore, .hgignore, .ignore, .rgignore]
      Fl: xdsl
  VHDL:
    description: |-
      VHDL is a hardware description language used for modeling and
      simulating digital systems.
    links: {Reference: https://www.accellera.org/downloads/standards/vhdl}
    source:
      Ext: [.vhd, .vhdl]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xhdl
      Bc: [[--, "\n"]]
  Velocity:
    description: |-
      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".
    links: {Website: https://velocity.apache.org/}
    source:
      Ext: [.vm]
      Bc: [['#*', '*#'], ['##', "\n"]]
      Fl: xtpl
  Vertex Shader File:
    description: |-
      Vertex Shader files contain programs executed in the vertex processing
      stage of the GPU rendering pipeline. They are typically written in
      shading languages such as GLSL and define how individual vertices are
      transformed, including operations like coordinate space conversion,
      lighting preparation, and passing data to later pipeline stages. These
      shaders operate on per-vertex inputs and produce outputs that are
      interpolated across primitives for use by fragment shaders. They are
      used in real-time graphics applications including games,
      visualization, and GPU-accelerated rendering systems.
    links: {Website: https://www.khronos.org/opengl/wiki/Vertex_Shader, Reference: https://www.khronos.org/opengl/wiki/Core_Language_(GLSL)}
    source:
      Ext: [.vert, .vsh]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
      Bc: [[//, "\n"]]
  Vim script:
    aka: [VimL, VimScript]
    description: |-
      Vim script (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.
    links: {Introduction: http://learnvimscriptthehardway.stevelosh.com}
    source:
      Ext: [.vim]
      Files: [_vimrc, .vimrc, _gvimrc, .gvimrc, vimrc, gvimrc]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcfg
      Bc: [['"', "\n", sol]]
  Visual Basic:
    aka: ['Visual-Basic']
    description: |-
      Visual Basic is a family of programming languages developed by
      Microsoft, designed to make Windows application development accessible
      and rapid. The modern Visual Basic compiler in Roslyn is open source.
    links: {Syntax: https://learn.microsoft.com/en-us/dotnet/visual-basic/language-reference/}
    source:
      Ext: [.vb]
      Co: ['for ', for(, 'if ', if(, 'elseif ', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [["'", "\n"]]
  VRML:
    description: |-
      VRML (Virtual Reality Modeling Language) is a language for describing
      3D scenes and interactive environments.
    links: {Website: https://www.web3d.org/}
    source:
      Ext: [.wrl]
      Str: [['"', '"']]
      Fl: xmdl
      Bc: [['#', "\n"]]
  VSCode Workspace:
    description: |-
      A workspace definition format used by Visual Studio Code to group
      folders and customize the editing environment for multi-root
      projects. It enables consistent development setups across teams by
      capturing environment-specific preferences alongside project
      structure.
    links: {Reference: https://code.visualstudio.com/docs/editor/multi-root-workspaces, Repository: https://github.com/microsoft/vscode}
    source:
      Ext: [.code-workspace]
      Like: JSON-like
      Fl: xcfg
  Vue:
    description: |-
      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.
    links: {Website: https://vuejs.org/}
    source:
      Ext: [.vue]
      Like: XML-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  Vyper:
    description: |-
      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.
    links: {Website: https://vyperlang.org/}
    source:
      Ext: [.vy]
      Str: [['"', '"', bse]]
      Fl: xctr
      Bc: [['#', "\n"]]
  waf:
    description: |-
      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.
    links: {Website: https://waf.io/}
    source:
      Files: [wscript]
      Str: [['"""', '"""', ml], ["'''", "'''", ml]]
      Fl: xlsbc|xbld
      Bc: [['#', "\n"]]
  Wavefront OBJ:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/Wavefront_.obj_file}
    source:
      Ext: [.obj]
      Fl: xmdl
      Bc: [['#', "\n"]]
  WDL:
    aka: ['Workflow Description Language']
    description: |-
      WDL is an open standard for describing data-processing workflows and
      command-line tasks. WDL documents define tasks, workflows, typed
      inputs and outputs, calls, scatter blocks, conditionals, runtime
      requirements, metadata, and shell command sections that can be
      executed by workflow engines across local, cluster, and cloud
      environments.
    links: {Website: https://openwdl.org/, Specification: https://docs.openwdl.org/}
    source:
      Ext: [.wdl]
      Bc: [['#', "\n"]]
      Str: [['<<<', '>>>', ml], ['"', '"', bse], ["'", "'", bse]]
      Co: ['workflow ', 'task ', 'call ', 'scatter ', 'if ', 'then ', 'else ', 'input ', 'output ', 'runtime ', 'requirements ', 'hints ', 'command ', 'struct ', '&& ', '|| ', '!= ', '== ']
      Fl: xdsl
  WESL:
    aka: ['WebGPU Enhanced Shading Language']
    description: |-
      WESL (WebGPU Enhanced Shading Language) is a community-driven
      proposal designed to extend the standard W3C WebGPU Shading
      Language (WGSL) with practical features like import statements,
      conditional compilation, and modular shader libraries. Unlike
      the base WGSL, WESL is not natively supported by WebGPU
      browsers; instead, it functions as a superset that is
      compiled or "lowered" into standard WGSL before being passed
      to the GPU pipeline.
    links: {Specification: https://github.com/wgsl-tooling-wg/wesl-spec}
    source:
      Ext: [.wesl]
      Like: C-like
      St: ;
      Co: [for (, for(, 'if ', if(, 'switch ', 'while ', while(, 'else ', 'else{', '|| ', '&& ', '!= ', '== ']
      Fl: xshd
  WGSL:
    aka: ['WebGPU Shading Language']
    description: |-
      WGSL (WebGPU Shading Language) is the shader language standardized for
      the WebGPU graphics API.
    links: {Website: https://www.w3.org/TR/WGSL/}
    source:
      Ext: [.wgsl]
      Like: C-like
      St: ;
      Co: [for (, for(, 'if ', if(, 'switch ', 'while ', while(, 'else ', 'else{', '|| ', '&& ', '!= ', '== ']
      Fl: xshd
  WIT:
    aka: ['WASM Interface Type', 'WebAssembly Interface Types']
    description: |-
      WIT (WASM Interface Type) is the interface-definition language used by
      the WebAssembly Component Model. WIT files define packages,
      interfaces, worlds, resources, functions, and data types that describe
      contracts between WebAssembly components.
    links: {Reference: https://component-model.bytecodealliance.org/design/wit.html}
    source:
      Ext: [.wit]
      Fl: xidl
      Str: [['"', '"', bse]]
      Bc: [[/*, '*/', cnest], [//, "\n"]]
  WiX:
    description: |-
      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.
    links: {Reference: https://wixtoolset.org/docs/, Repository: https://github.com/wixtoolset/wix}
    source:
      Ext: [.wxs, .wxi, .wxl]
      Like: XML-like
      Fl: xbld
  WebAssembly:
    description: |-
      A near superset of wat syntax that is more convenient for human
      developers to write directly. Note: this is not WASM!
    links: {Repository: https://github.com/kanaka/wam, Specification: https://webassembly.github.io/spec/, Syntax: https://github.com/WebAssembly/spec/tree/master/interpreter/#s-expression-syntax}
    source:
      Ext: [.wat, .wast]
      Bc: [[(;, ;)], [;, "\n"]]
      Str: [['"', '"', bse]]
  WebIDL:
    description: |-
      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.
    links: {Reference: https://heycam.github.io/webidl/}
    source:
      Ext: [.webidl]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  Wolfram:
    aka: [Mathematica]
    description: |-
      Wolfram (Mathematica) is a 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.

      Open-source implementations with Mathematica-compatible syntax and
      evaluation exist.
    links: {Reference: https://mathics.org/}
    source:
      Ext: [.nb, .wl, .wls]
      Like: Pascal-like
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xmat
  Wren:
    description: |-
      Wren is a small object-oriented scripting language designed to be
      embedded in applications.  Programs define classes containing fields
      and methods, and execution proceeds by sending messages to objects.
      Everything in the language is an object, including numbers, strings,
      lists, and functions.  Wren is intended primarily as an extension or
      scripting facility within host applications.
    links: {Website: https://wren.io/, Repository: https://github.com/wren-lang/wren}
    source:
      Ext: [.wren]
      Bc: [[/*, '*/', cnest], [//, "\n"]]
      Str: [['"""', '"""', ml], ['"', '"', ml|bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  WSDL:
    aka: ['Web Services Description Language']
    description: |-
      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.
    links: {Website: https://www.w3.org/TR/wsdl20/}
    source:
      Ext: [.wsdl]
      Like: XML-like
      Fl: xidl
  XAML:
    aka: [Xaml]
    description: |-
      XAML is a declarative markup language used for constructing and
      initializing object graphs, primarily in UI frameworks such as WPF,
      UWP, and .NET MAUI. It is most commonly used to define user interface
      layouts, resources, styles, and bindings in applications built on the
      Microsoft .NET platform.

      This is not the same language as AXAML, though they are
      functionally similar.
    links: {Reference: https://learn.microsoft.com/en-us/dotnet/desktop/wpf/xaml/, Repository: https://github.com/dotnet/wpf}
    source:
      Ext: [.xaml]
      Like: XML-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xidl
  XC:
    description: |-
      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.
    links: {Specification: https://www.xmos.com/developer/xc-specification}
    source:
      Ext: [.xc]
      Like: C-like
      St: ;
  XMake:
    description: |-
      XMake is a cross-platform build configuration language used by the
      xmake build system.  Build scripts describe targets, dependencies,
      compiler options, and build rules that the tool uses to generate and
      execute build tasks for software projects.
    links: {Website: https://xmake.io/, Repository: https://github.com/xmake-io/xmake}
    source:
      Ext: [.xmake]
      Files: [xmake.lua, xpack.lua]
      Bc: [['--[[', ']]'], [--, "\n"]]
      Str: [['[[', ']]', ml], ['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'while ', while(, 'else ', else(, 'elseif ', elseif(, 'until ', until(, 'or ', 'and ', '~= ', '== ']
      Fl: xbld
  XMI:
    description: |-
      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.
    links: {Website: https://www.omg.org/spec/XMI/}
    source:
      Ext: [.xmi]
      Like: XML-like
      Fl: xser
  XQuery:
    description: |-
      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.
    links: {Website: https://www.w3.org/TR/xquery/}
    source:
      Ext: [.xq, .xquery, .xqy, .xql]
      Bc: [['(:', ':)', cnest]]
      Fl: xdsl|xqry
  XSD:
    description: |-
      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.
    links: {Website: https://www.w3.org/XML/Schema}
    source:
      Ext: [.xsd]
      Like: XML-like
      Fl: xdsl
  XSL:
    description: |-
      XSL (Extensible Stylesheet Language) is a family of XML-based
      languages used to transform and format XML documents.  XSL stylesheets
      are written as XML documents that describe template rules and
      formatting instructions applied to an input XML tree.
    links: {Website: https://www.w3.org/TR/xslt/}
    source:
      Ext: [.xsl]
      Like: XML-like
      Fl: xdsl
  XSLT:
    description: |-
      XSLT (XSL Transformations) defines rules for converting XML documents
      into other XML formats, HTML, or text.  XSLT stylesheets are written
      as XML documents that describe template rules and formatting
      instructions applied to an input XML tree.
    links: {Website: https://www.w3.org/TR/xslt/}
    source:
      Ext: [.xslt]
      Like: XML-like
      Fl: xtrn
  Xtend:
    description: |-
      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.
    links: {Website: https://www.eclipse.org/xtend/}
    source:
      Ext: [.xtend]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  XUL:
    description: |-
      A user interface description language used to define application
      interfaces in Mozilla-based environments, enabling declarative
      construction of UI layouts and interaction with underlying application
      logic.
    links: {Reference: https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XUL}
    source:
      Like: 'XML-like'
      Ext: [.xul]
      Fl: xidl
  Yabasic:
    description: |-
      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.
    links: {Website: https://www.yabasic.de/}
    source:
      Ext: [.yab]
      Str: [['"', '"']]
      Bc: [[//, "\n"], ['#', "\n"], [REM, "\n"], [rem, "\n"]]
  YANG:
    aka: [Yang]
    description: |-
      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.
    links: {Reference: https://datatracker.ietf.org/doc/html/rfc7950}
    source:
      Ext: [.yang]
      Like: C-like
      Fl: xcfg
  YARA:
    description: |-
      YARA is a rule language designed for identifying and classifying
      malware by describing patterns found in files or process memory. Rules
      define sets of textual or binary strings together with logical
      conditions that determine when a file or memory region should be
      considered a match. The language is widely used in malware research,
      incident response, and threat hunting to detect known malware families
      and search large datasets for indicators of compromise.
    links: {Repository: https://virustotal.github.io/yara/}
    source:
      Ext: [.yar, .yara]
      Like: C-like
      Fl: xdsl
  Yarn:
    description: |-
      Yarn Spinner is a scripting language for writing branching dialogue
      and narrative content in games. It allows authors to define dialogue
      nodes, choices, and flow control using a simple text-based format that
      can be integrated into game engines such as Unity. Yarn scripts are
      used to structure interactive conversations and narrative sequences in
      story-driven games.
    links: {Website: https://yarnspinner.dev/, Repository: https://github.com/YarnSpinnerTool/YarnSpinner}
    source:
      Ext: [.yarn]
      Co: ['<<if ', '<<elseif ', '<<else ', ' eq ', ' == ', ' neq ', ' ! ', ' gt ', ' > ', ' lt ', ' < ', ' lte ', ' <= ', ' gte ', ' >= ', ' xor ', ' ^ ', ' and ', ' && ', ' || ', ' or ']
      Fl: xdsl
      Bc: [[//, "\n"]]
  Yul:
    description: |-
      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.
    links: {Reference: https://docs.soliditylang.org/en/latest/yul.html}
    source:
      Ext: [.yul]
      Like: C-like
      Fl: xirf
  Zen C:
    aka: [Zen-C]
    description: |-
      Zen C is a statically typed systems programming language that compiles
      to human-readable GNU C/C11 while preserving direct C ABI
      compatibility. It adds modern conveniences such as type inference,
      pattern matching, traits, monomorphized generics, async/await, and
      RAII-style resource management without hiding the generated C from
      developers.
    links: {Website: https://www.zenc-lang.org/, Reference: https://docs.zenc-lang.org/, Repository: https://github.com/zenc-lang/zenc}
    source:
      Ext: [.zc]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'while ', while(, 'loop ', 'loop{', 'else ', 'else{', '|| ', '&& ', '!= ', '== ', 'match ', match(]
  ZenCode:
    description: |-
      ZenCode is a scripting language originally developed in the Minecraft modding
      ecosystem, especially around CraftTweaker-style configuration and
      extension workflows. It has ambitions to be a general-purpose language.
      Not to be confused with "Zencode".
    links: {Website: https://docs.blamejared.com/MineTweaker/en/zencode_specification/, Repository: https://github.com/ZenCodeLang/ZenCode}
    source:
      Ext: ['.zs']
      Fl: ['xdsl']
  Zencode:
    description: |-
      Zencode is a domain-specific scripting language used by the Zenroom
      ecosystem for cryptographic workflows. Not to be confused with "ZenCode".
    links: {Website: https://dev.zenroom.org/}
    source:
      Ext: [.zen]
      Fl: xdsl
      Bc: [['#', "\n"]]
  Zephir:
    description: |-
      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.
    links: {Website: https://docs.zephir-lang.com/}
    source:
      Ext: [.zep]
      Like: C-like
      St: ;
  Zig:
    description: |-
      Zig is a systems programming language designed for robustness,
      optimality, and maintainability.
    links: {Reference: https://ziglang.org/documentation/master/}
    source:
      Ext: [.zig]
      St: ;
      Str: [['"', '"', bse]]
      Co: ['catch ', 'while ', 'for ', 'if ', 'else ', 'errdefer ', 'try ', 'switch ', 'orelse ', '||', '&&', '!=', ==]
      Bc: [[//, "\n"]]
  zsh:
    aka: [Zsh]
    description: |-
      zsh is a Unix command shell with advanced scripting and interactive
      features.
    links: {Website: https://zsh.sourceforge.io/}
    source:
      Ext: [.zsh]
      She: [zsh]
      Like: Shell-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  ZoKrates:
    description: |-
      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.
    links: {Website: https://zokrates.github.io/}
    source:
      Ext: [.zok]
      Bc: [[/*, '*/'], [//, "\n"]]
      Co: ['for ', 'if ', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xctr
    #
    # Entries with verifiers or Require or Forbid checks begin here:
    #
    # Python
  Python:
    description: |-
      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.
    links: {Reference: https://docs.python.org/3/reference/lexical_analysis.html}
    source:
      Ext: [.py]
      She: [python]
      Like: Python-like
      Co: ['for ', for(, 'while ', while(, 'if ', if(, 'elif ', elif(, 'else ', 'else:', 'match ', match(, 'try ', 'try:', 'except ', 'except:', 'finally ', 'finally:', 'with ', with (, 'and ', and(, 'or ', or(]
  Python2:
    description: |-
      Python2 was an obsolete early version of Python. It was end-of-lifed
      in January 2020.
    links: {Reference: https://www.python.org/downloads/release/python-272/}
    source:
      Ext: [.py2]
      She: [python2]
      Like: Python-like
  Python3:
    description: |-
      Python3 is the name used to distinguish the modern version of Python
      from the obsolete Python2 dialect,
    source:
      Ext: [.py3]
      She: [python3]
      Like: Python-like
    #
    # YAML
    #
  DockerCompose:
    description: |-
      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.
    links: {Website: https://docs.docker.com/compose/}
    base:
      Like: YAML-like
      Fl: xcfg
    variants:
      by file:
        Files: [compose.yaml, compose.yml, docker-compose.yaml, docker-compose.yml]
      by extension:
        Ext: [.yaml, .yml]
        Require: ['^\s*(?:services|volumes|networks|configs|secrets|include):|\bimage:']
  k8s manifest:
    description: |-
      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.
    links: {Reference: https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/}
    source:
      Ext: [.yaml, .yml]
      Like: YAML-like
      Require: ['apiVersion|kind:|metadata:|spec:']
      Fl: xcfg
  Liquibase:
    description: |-
      Liquibase is a database schema change management system that uses
      structured changelog files to describe and apply incremental
      modifications to database schemas. It supports multiple serialization
      formats, with XML being the canonical form, and executes changes in a
      controlled, versioned manner across environments.

      Not to be confused with the Liquid template language.
    links: {Website: https://docs.liquibase.com/, Repository: https://github.com/liquibase/liquibase}
    source:
      Ext: [.xml, .yaml, .yml, .json]
      Like: XML-like
      Require: [<\s*databaseChangeLog\b, <\s*changeSet\b]
      Fl: xcfg
  PromQL YAML:
    description: |-
      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.
    links: {Reference: https://prometheus.io/docs/prometheus/latest/configuration/alerting_rules/}
    source:
      Ext: [.yaml, .yml]
      Like: YAML-like
      Require: [expr:|record:|alert|rate\(]
      Fl: xqry
  YAML:
    description: |-
      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.
    links: {Website: https://yaml.org/spec/}
    source:
      Ext: [.yaml, .yml]
      Like: YAML-like
      Fl: xser
    #
    # Miscellaneous extension collisions.
    #
  AMPLE:
    description: |-
      AMPLE is a text-based linguistic analysis format used to represent
      morphological parsing and lexical information in structured
      interlinear-style data. It is associated with language analysis
      workflows in field linguistics and is used to encode relationships
      between lexical entries, affixes, and parsed word forms for downstream
      processing and study.
    links: {Reference: https://software.sil.org/ample/, Repository: https://github.com/sillsdev}
    source:
      Ext: [.amp]
      Str: [['"', '"', ml]]
      Require: ['^\s*\\(?:begindata|enddata)\b', '^\s*[A-Za-z0-9_]+\s*:\s*']
      Fl: xser
      Bc: [[;, "\n"]]
  AngelScript:
    description: |-
      AngelScript is an embeddable scripting language with a C++-like syntax,
      designed for use in applications such as games and simulation tools. It
      provides statically typed scripts with classes, interfaces, object
      handles, namespaces, and host-registered application APIs, allowing
      program logic to be compiled and executed by a small scripting engine
      integrated into a larger native program.
    links: {Reference: https://www.angelcode.com/angelscript/sdk/docs/manual/doc_script.html, Repository: https://github.com/AngelScript/AngelScript}
    base:
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"""', '"""', ml], ['"', '"', bse], ["'", "'", bse]]
      St: ;
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'switch ', 'while ', 'else ', 'try ', 'catch ', '|| ', '&& ', '!= ', '== ', '!is ']
    variants:
      native extension:
        Ext: [.angelscript]
      ActionScript extension:
        Ext: [.as]
        Require: ['\bfuncdef\b|\bmixin\b|\bshared\b|\bexternal\b|\b(?:int8|int16|int32|int64|uint8|uint16|uint32|uint64)\b|\b[A-Za-z_][A-Za-z0-9_]*@\s*[A-Za-z_]|\b(?:void|bool|int|uint|float|double|string|auto)\s+[A-Za-z_][A-Za-z0-9_]*\s*\(']
  ActionScript:
    description: |-
      ActionScript is a programming language used primarily within Adobe the
      (now-discontinued) Flash and Adobe AIR environments for developing
      interactive applications, animations, and multimedia content. It
      evolved through several versions, with later iterations adopting a
      class-based model and a syntax aligned with ECMAScript, enabling
      structured application development within the Flash runtime.
    links: {Reference: https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/, Repository: https://github.com/adobe/avmplus}
    source:
      Ext: [.as]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", ml|bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Require: [\bpackage\b|\bimport\b|\bclass\b|\binterface\b|\bfunction\b|\bvar\b|\bconst\b|\bnamespace\b|\buse\s+namespace\b]
  ACPI ASL:
    aka: ['ACPI Source Language']
    description: |-
      ACPI ASL is the source language used by platform firmware vendors to
      describe ACPI definition blocks and control methods that are compiled
      into AML bytecode. ASL files define namespace objects, devices,
      methods, operation regions, fields, resource templates, and table data
      used by operating systems during hardware discovery and power
      management.
    links: {Reference: https://uefi.org/specs/ACPI/6.5/19_ASL_Reference.html, Compiler Docs: https://www.intel.com/content/www/us/en/developer/topic-technology/open/acpica/documentation.html}
    source:
      Ext: [.asl, .dsl]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse]]
      Require: ['(?i)^\s*(?:DefinitionBlock|Scope|Device|Processor|ThermalZone|OperationRegion|Field|Method|Name|External|Include|ResourceTemplate)\s*\(']
      Co: ['If ', 'Else ', 'ElseIf ', 'Switch ', 'Case ', 'Default ', 'While ', 'For ', 'Break ', 'Continue ', 'Return ', 'And ', 'Or ', 'Not ', 'LAnd ', 'LOr ', 'LNot ', 'LEqual ', 'LNotEqual ']
      Fl: xhdl
  ASP:
    description: |-
      ASP (Active Server Pages) was a now-obsolete a server-side scripting
      technology used for generating dynamic web pages by embedding
      executable code within HTML documents. ASP was widely used in early
      web applications built on Microsoft's web server platform before being
      largely superseded by later frameworks, including ASP.NET.
    links: {Introduction: https://en.wikipedia.org/wiki/Active_Server_Pages}
    source:
      Ext: [.asp, .asa]
      Like: XML-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl|xdead
      Require: [<%|<%=|<%@|Response.|Request.|Server.|Session.|Application.]
  AnsProlog:
    description: |-
      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.
    links: {Website: https://potassco.org/, Introduction: https://en.wikipedia.org/wiki/Answer_set_programming}
    source:
      Ext: [.lp, .asp]
      Bc: [[/*, '*/'], ['%', "\n"]]
      St: .
  BCPL:
    description: |-
      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.
    links: {Reference manual: https://www.bell-labs.com/usr/dmr/www/bcpl.html}
    source:
      Ext: [.b]
      Str: [['"', '"'], ["'", "'"]]
      Fl: xdead
      Require: [LET]
      Bc: [[//, "\n"]]
  B:
    description: |-
      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.
    links: {User's Manual: https://www.bell-labs.com/usr/dmr/www/kbman.html}
    source:
      Ext: [.b]
      Bc: [[/*, '*/']]
      St: ;
      Str: [['"', '"']]
      Fl: xdead
  FreeBasic:
    description: |-
      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.
    links: {Website: https://www.freebasic.net/}
    source:
      Ext: [.bas, .bi]
      Like: VBA-like
      Bc: [[/', "'/"], ["'", "\n"]]
      Require: [^\s*Using\b|^\s*Dim\b]
      Forbid: ['^[0-9]']
  BASIC:
    description: |-
      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.
    links: {Reference: https://www.dartmouth.edu/basicfifty/}
    source:
      Ext: [.bas]
      Co: ['for ', for(, 'if ', if(, 'elseif ', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: num
      Bc: [[REM, "\n"], [rem, "\n"]]
  Berry:
    description: |-
      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.
    links: {Reference: https://github.com/Skiars/berry}
    source:
      Ext: [.be]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Require: [\bend\b|\bdef\b|\bimport\b]
      Bc: [['#', "\n"]]
  NAnt script:
    description: |-
      NAnt Script is a build configuration format used by the NAnt build
      system to define targets, tasks, and dependencies for automating
      software builds in .NET environments. It organizes build logic into
      declarative project files that are executed by the NAnt engine to
      perform compilation, packaging, and other development tasks.
    links: {Website: http://nant.sourceforge.net/, Repository: https://github.com/nant/nant}
    source:
      Ext: [.build, .nant]
      Like: XML-like
      Fl: xbld
      Require: [<\s*project\b]
  Starlark:
    description: |-
      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.
    links: {Website: https://starlark-lang.org/}
    source:
      Ext: [.bzl]
      Files: [BUILD, WORKSPACE]
      Str: [['"', '"', bse], ["'", "'"]]
      Fl: xcfg
      Require: [\bdef\b|\bload\(|\brule\(|\bnative\.]
      Forbid: [\bclass\b|\bimport\s|\basync\b]
      Bc: [['#', "\n"]]
  Bazel:
    description: |-
      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.
    links: {Reference: https://bazel.build/reference}
    source:
      Ext: [.bazel, .bzl]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", ml], ['"', '"', bse], ["'", "'"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xbld
      Bc: [['#', "\n"]]
  HAProxy:
    description: |-
      HAProxy configuration files define load-balancing and proxy behavior
      for HAProxy. They are organized into sections such as global,
      defaults, frontend, backend, and listen, with directives for binding
      sockets, selecting backends, defining servers, access-control lists,
      health checks, logging, TLS, and HTTP or TCP routing behavior.
    links: {Reference: https://docs.haproxy.org/3.2/configuration.html}
    source:
      Ext: [.cfg]
      Files: [haproxy.cfg]
      Bc: [['#', "\n"]]
      Str: [['"', '"', bse], ["'", "'"]]
      Require: ['^\s*(?:global|defaults|frontend|backend|listen|peers|resolvers|mailers|program)\b|\b(?:bind|server|use_backend|default_backend|acl|http-request|tcp-request|option\s+httpchk)\b']
      Fl: xcfg
  CFML:
    aka: [ColdFusion]
    description: |-
      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.
    links: {Website: https://cfdocs.org/}
    source:
      Ext: [.cfm, .cfc, .cfml]
      Bc: [["<!--", "-->"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
      Require: [<cf|</cf|<cfset\b|<cfif\b|<cfoutput\b|<cfloop\b]
  CFScript:
    aka: ['ColdFusion CFScript']
    description: |-
      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.
    links: {Website: https://cfdocs.org/}
    source:
      Ext: [.cfs]
      Like: C-like
      Require: ['\bcomponent\s*\{|\bfunction\b|\bproperty\b|\bif\s*\(|\bfor\s*\(|\bwhile\s*\(|;']
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  GitConfig:
    aka: ['Git config']
    description: |-
      GitConfig files are Git configuration files used for system, global,
      repository, work-tree, and submodule settings. They use a Git-specific
      INI-like syntax with square-bracketed sections, optional quoted
      subsections, case-insensitive variable names, boolean shorthand,
      include directives, and key-value assignments that control Git
      commands, remote definitions, branches, credentials, diff and merge
      tools, and repository behavior.
    links: {Reference: https://git-scm.com/docs/git-config, Gitmodules: https://git-scm.com/docs/gitmodules}
    base:
      Bc: [['#', "\n"], [;, "\n"]]
      Str: [['"', '"', bse]]
      Co: ['[core]', '[user]', '[alias]', '[remote ', '[branch ', '[url ', '[include]', '[includeIf ', '[submodule ', 'path =', 'url =', 'fetch =', 'merge =', 'insteadOf =', 'pushInsteadOf =']
      Fl: xcfg
    variants:
      Git-specific basenames:
        Files: [.gitconfig, .gitmodules, gitconfig, config.worktree]
        Require: ['(?i)^\s*\[[A-Za-z][A-Za-z0-9-]*(?:\.[A-Za-z][A-Za-z0-9-]*)*(?:\s+"(?:[^"\\]|\\.)*")?\]\s*$']
      ambiguous config basename:
        Files: [config]
        Require: ['(?i)^\s*\[(?:core|user|alias|color|branch|remote|url|include|includeIf|push|pull|fetch|merge|diff|difftool|mergetool|credential|filter|submodule|commit|tag|init|safe|gc|http|https|ssh|gpg|protocol|rerere|rebase|status|format|sendemail|gui)(?:\s+"(?:[^"\\]|\\.)*")?\]\s*$']
  GitAttributes:
    aka: ['Git attributes']
    description: |-
      GitAttributes files define Git attributes for path patterns. Each
      non-comment line gives a pattern followed by attributes that can be
      set, unset, set to a value, or returned to the unspecified state.
      Git uses these attributes to control text normalization, line endings,
      diff and merge drivers, filters, archive export behavior, encodings,
      and attribute macros.
    links: {Reference: https://git-scm.com/docs/gitattributes}
    base:
      Bc: [['#', "\n", sol]]
      Str: [['"', '"', bse]]
      Require: ['^\s*(?:\[attr\][A-Za-z][A-Za-z0-9_.-]*|(?:"(?:[^"\\]|\\.)+"|[^#\s]+))\s+(?:!?-?[A-Za-z][A-Za-z0-9_.-]*(?:=[^\s#]+)?\s+)*(?:!?-?(?:text|eol|diff|merge|filter|ident|working-tree-encoding|whitespace|crlf|delta|export-ignore|export-subst|binary|linguist-[A-Za-z0-9_.-]+|lockable|lfs|builtin_objectmode)(?:=[^\s#]+)?)(?:\s+!?-?[A-Za-z][A-Za-z0-9_.-]*(?:=[^\s#]+)?)*\s*$']
      Co: [' text', ' -text', ' text=', ' eol=', ' diff', ' -diff', ' merge', ' -merge', ' filter=', ' ident', ' -ident', ' working-tree-encoding=', ' export-ignore', ' export-subst', ' binary', '[attr]']
      Fl: xcfg
    variants:
      worktree file:
        Files: [.gitattributes]
      Git directory attributes:
        Files: [attributes]
  HOCON:
    aka: ['Human-Optimized Config Object Notation']
    description: |-
      HOCON is a human-editable configuration format and JSON superset used
      by JVM applications and related configuration tooling. HOCON files
      support comments, includes, substitutions, unquoted keys and values,
      path expressions, arrays, objects, and simplified assignment syntax for
      application and library configuration.
    links: {Reference: https://github.com/lightbend/config/blob/main/HOCON.md, Repository: https://github.com/lightbend/config}
    source:
      Ext: [.conf]
      Files: [application.conf, reference.conf]
      Bc: [[/*, '*/'], [//, "\n"], ['#', "\n"]]
      Str: [['"""', '"""', ml|bse], ['"', '"', bse]]
      Require: ['^\s*include\s+(?:required\s*)?(?:file|classpath|url)?\s*\(|\$\{[?A-Za-z0-9_.-]+\}|^\s*[A-Za-z0-9_.-]+(?:\s+|\s*[=:])\s*(?:\{|\[|"(?:[^"\\]|\\.)*"|[A-Za-z0-9_.-]+)']
      Fl: xcfg
  Component Pascal:
    aka: ['BlackBox Component Pascal']
    description: |-
      Component Pascal is Oberon microsystems' refinement of Oberon-2, a
      statically typed, modular programming language in the Pascal, Modula-2,
      and Oberon tradition. It adds type extension with methods, dynamic
      module loading, separate compilation, strong type checking across
      module boundaries, and garbage collection, and is most closely
      associated with the BlackBox Component Builder environment and related
      command-line compilers.
    links: {Website: https://blackbox.oberon.org/, Reference: https://blackbox.oberon.org/cp-lang.pdf}
    source:
      Ext: [.cp]
      Require: ['^\s*MODULE\s+[A-Za-z_][A-Za-z0-9_]*\s*;']
      Bc: [[(*, '*)', cnest]]
      Str: [['"', '"'], ["'", "'"]]
      St: ;
      Sb: BEGIN
      Eb: END
      Fl: xssep
      Co: ['IF ', 'ELSIF ', 'ELSE ', 'CASE ', 'WHILE ', 'REPEAT ', 'FOR ', 'LOOP ', 'WITH ', 'OR ', '& ', '# ', '= ']
  C#:
    description: |-
      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.
    links: {Reference: https://learn.microsoft.com/dotnet/csharp/}
    source:
      Ext: [.cs]
      She: [dotnet]
      Like: C-like
      St: ;
      Str: [['@"', '"', ml]]
      Require: [//|/*]
      Co: ['for ', for(, 'if ', if(, 'foreach ', foreach(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  D:
    description: |-
      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.
    links: {Reference: https://dlang.org/spec/spec.html}
    source:
      Ext: [.d]
      She: [rdmd]
      Bc: [[/+, +/, cnest], [//, "\n"]]
      St: ;
      Str: [['"', '"', bse]]
      Require: ['^\s*module\s+[A-Za-z_][A-Za-z0-9_.]*\s*;|^\s*import\s+([A-Za-z_][A-Za-z0-9_.]*)(\s*[:=,].*)?;|\bunittest\b|\bmixin\s*\(|\btemplate\s+[A-Za-z_][A-Za-z0-9_]*']
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  DTrace:
    description: |-
      DTrace is a dynamic instrumentation language used to observe and
      analyze the behavior of running systems. It allows you to declare
      probes that trigger actions. Built-in actions include trace, printf,
      stack, and aggregation operators used for profiling and performance
      analysis of kernel and user-space activity.
    links: {Website: https://dtrace.org/, Reference: https://docs.oracle.com/cd/E53394_01/html/E53395/gkwpg.html, Repository: https://github.com/oracle/dtrace-utils}
    source:
      Ext: [.d]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse], ["'", "'"]]
      Require: ['\bself->|\bthis->|^\s*(profile|tick)-|^[A-Za-z_][A-Za-z0-9_]*:[^:]*:[^:]*:[A-Za-z_*?][^\s{]*|@\[[^]]*\]']
      Fl: xdsl
  Module-Definition:
    description: |-
      Module-Definition is the Windows module-definition format used to
      control linker-visible properties of a program image, especially DLL
      export tables and related image attributes. While primarily associated
      with PE/COFF toolchains on Windows and is supported not only by
      Microsoft LINK but also by GNU ld for PE targets and by LLVM lld, as
      well as Cygwin,
    links: {Reference: "https://learn.microsoft.com/en-us/cpp/build/reference/module-definition-dot-def-files?view=msvc-170"}
    source:
      Ext: [.def]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Require: ['^\s*(?:LIBRARY|NAME|EXPORTS|HEAPSIZE|STACKSIZE|SECTIONS|STUB|VERSION)\b']
      Bc: [[;, "\n", sol]]
      Fl: xirf
  Apptainer:
    aka: ['Singularity Definition File']
    description: |-
      Apptainer definition files describe how to build container images.
      A definition file starts with a header that selects a bootstrap agent
      and base image, followed by optional percent-prefixed sections such as
      setup, files, environment, post, runscript, test, labels, and app
      sections. Many sections are shell scriptlets executed during image
      build or container runtime setup.
    links: {Reference: https://apptainer.org/docs/user/main/definition_files.html}
    source:
      Ext: [.def]
      Files: [Apptainer, Singularity]
      Like: Shell-like
      Require: ['^\s*Bootstrap\s*:']
      Fl: xbld
  Euclid:
    description: |-
      Euclid is a systems programming language developed as a derivative of
      Pascal with an emphasis on verifiable, reliable software for real-time
      and embedded systems. It was designed to support formal reasoning
      about programs, incorporating strong typing, module-based structure,
      and restrictions intended to eliminate unsafe constructs. The language
      was used in high-assurance contexts, including military and avionics
      software, where correctness and maintainability were critical. Its
      design influenced later safety-oriented languages and subsets used in
      certified systems.
    links: {Introduction: https://en.wikipedia.org/wiki/Euclid_(programming_language)}
    source:
      Ext: [.e, .eu]
      Str: [['"', '"']]
      Require: [\bimports\b|\bexports\b|\bpervasive\b|\binitially\b|\bpacked\b|\bbind\b|\bchecked\b|\bcollection\b|\bconverter\b|\bmachine\b|\botherwise\b|\breturns\b]
      Bc: [[--, "\n"]]
  Specman e:
    description: |-
      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.
    links: {Website: https://www.accellera.org/downloads/standards/e}
    source:
      Ext: [.e]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xhdl
      Require: [\bextend\b|\bunit\b|\bstruct\b|\bis also\b|\bverilog path\b|\bvhdl path\b]
      Bc: [[--, "\n"]]
  Euphoria:
    description: |-
      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.
    links: {Website: https://openeuphoria.org/}
    source:
      Ext: [.ex, .exw, .e]
      Bc: [[/*, '*/'], [--, "\n"]]
      Str: [['"', '"', bse]]
      Require: [\bsequence\b|\bfunction\b|\bend\s+function\b|puts\(]
      Forbid: [\bclass\b|\bdef\b|\bfn\b]
  Phix:
    description: |-
      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.
    links: {Reference: https://phix.x10.mx/docs/html/phix.htm}
    source:
      Ext: [.exw, .exu]
      Str: [['"', '"']]
      Bc: [[--, "\n"]]
  Eiffel:
    description: |-
      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.
    links: {Website: https://www.eiffel.org/doc/eiffel}
    source:
      Ext: [.e]
      Str: [['"', '"']]
      Require: [\bfeature\b|\binherit\b|\bcreate\b|\bdeferred\b|\brescue\b|\bensure\b|\brequire\b|\binvariant\b|\bredefine\b|\brename\b|\bseparate\b|\binspect\b|\bacross\b|\bagent\b|\balias\b|\bCurrent\b|\bResult\b]
      Bc: [[--, "\n"]]
  EEx:
    description: |-
      EEx is a templating language included with Elixir that allows Elixir
      code to be embedded inside text documents using special delimiters. It
      is commonly used to generate HTML and other structured output by
      combining markup with Elixir expressions and control structures. EEx
      templates are compiled into Elixir code and executed to produce the
      final rendered output.

      This is not the same language as HTML EEx, which more specifically
      targets HTML.
    links: {Website: https://hexdocs.pm/eex/, Repository: https://github.com/elixir-lang/elixir/tree/main/lib/eex}
    source:
      Ext: [.eex]
      Require: [<%=, <%#, '%>']
      Co: ['case ', 'cond ', 'if ', 'for ', 'with ', 'try ', 'catch ', 'rescue ', 'else ', 'and ', 'or ', 'not ', '|| ', '&& ', '!= ', '== ', '|> ', '<% ']
      Fl: xtpl
  Elixir:
    description: |-
      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.
    links: {Website: https://elixir-lang.org/}
    source:
      Ext: [.ex, .exs]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", ml], ['"', '"', bse]]
      Co: ['case ', 'cond ', 'if ', 'for ', 'with ', 'try ', 'catch ', 'rescue ', 'else ', 'and ', 'or ', 'not ', '|| ', '&& ', '!= ', '== ', '|> ']
      Fl: erlang
      Bc: [['#', "\n"]]
  HunspellAffix:
    description: |-
      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.
    links: {Website: https://hunspell.github.io/}
    source:
      Ext: [.aff]
      Fl: xcfg
      Require: [^SET\b|^FLAG\b|^PFX\b|^SFX\b]
  HyphenationPattern:
    description: |-
      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.
    links: {Reference: https://github.com/wachin/libreoffice-dictionaries-collection}
    source:
      Ext: [.dic]
      Fl: xcfg
      Require: ['[0-9]']
  HunspellDictionary:
    description: |-
      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.
    links: {Website: https://hunspell.github.io/}
    source:
      Ext: [.dic]
      Fl: xcfg
  Verilog Args File:
    description: |-
      Verilog argument files are used by hardware design toolchains to
      supply lists of source files and command-line options to simulators
      and related tools. Each line is interpreted as either a file reference
      or a directive, and files can include other argument files to form
      larger configurations. The format is not a programming language but a
      tool-consumed input mechanism for organizing build inputs and options
      across complex projects.

      https://verilator.org/guide/latest/exe_verilator.html
      https://eda-playground.readthedocs.io/en/latest/compile_run_options.html
    source:
      Ext: [.f]
      Fl: xhdl
      Require: [\b(-timescale|-mfcu|\+incdir\+|\+define\+|\+libext\+)\b]
      Bc: [[//, "\n"]]
  FASTQ:
    description: |-
      FASTQ is a text format used in bioinformatics for storing nucleotide
      sequences together with quality scores produced by DNA sequencing
      instruments. Each record consists of four lines containing a sequence
      identifier, the nucleotide sequence, a separator line beginning with a
      plus sign, and a line of encoded quality values corresponding to the
      sequence bases. FASTQ is widely used in genomics workflows for storing
      and exchanging sequencing reads.
    links: {Introduction: https://en.wikipedia.org/wiki/FASTQ_format}
    source:
      Ext: [.fastq, .fq]
      Require: ['^@', '^\+']
      Fl: xser
  Fortran77:
    aka: ['Fortran Legacy', 'FORTRAN Legacy']
    description: |-
      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
    links: {Reference: https://j3-fortran.org/doc/year/18/18-007r1.pdf}
    base:
      Str: [["'", "'"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: f77
    variants:
      legacy extension:
        Ext: [.for, .fpp, .ftn, .f77, .pfo]
      common extension:
        Ext: [.f]
        Require: ['(?i)hpf|omp|PROGRAM|SUBROUTINE|FUNCTION|COMMON|EQUIVALENCE|BLOCK\s+DATA|IMPLICIT\s+NONE|DOUBLE\s+PRECISION|COMPLEX|DIMENSION|SAVE|DATA\s+|FORMAT\s*\(|CONTINUE|STOP|RETURN|GO\s+TO|ASSIGN\s+\d+\s+TO']
  GLSL Fragment Shader File:
    description: |-
      GLSL fragment shader files define programs that compute the final color
      and other per-fragment outputs in a graphics rendering pipeline. They are
      used in OpenGL and related systems to control how pixels are shaded,
      including lighting, texturing, and post-processing effects, and are
      executed for each fragment generated during rasterization.
    links: {Reference: https://www.khronos.org/opengl/wiki/Fragment_Shader, Specification: https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf, Repository: https://github.com/KhronosGroup/glslang}
    source:
      Ext: [.frag, .fs]
      Like: C-like
      Require: [/\*]
      Forbid: ['\(\*']
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xshd
  F#:
    description: |-
      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.
    links: {Website: https://learn.microsoft.com/en-us/dotnet/fsharp/}
    source:
      Ext: [.fs]
      Like: ML-like
      Str: [['@"', '"', ml], ['"""', '"""', ml]]
      Require: [\bmodule\b|\bopen\b|\blet\b|\btype\b]
      Co: ['for ', for(, 'if ', if(, 'match ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[//, "\n"]]
  F# Script:
    description: |-
      F# Script is a scripting form of the F# programming language used for
      interactive execution and lightweight automation. It extends standard
      F# source with directives for loading assemblies and source files,
      enabling rapid experimentation, prototyping, and scripting within 
      the .NET environment.
    links: {Reference: https://learn.microsoft.com/en-us/dotnet/fsharp/tools/fsharp-interactive/, Repository: https://github.com/dotnet/fsharp}
    source:
      Ext: [.fsx]
      Like: F#
  Forth:
    description: |-
      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,
    links: {Reference: http://www.forth.org/fig.html}
    base:
      Bc: [['( ', ' )'], ['\ ', "\n"]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
    variants:
      common extension:
        Ext: [.fs]
        Require: [^:|\bVARIABLE\b|\bCONSTANT\b|\bIF\b|\bTHEN\b]
      legacy extension:
        Ext: [.forth]
  GCode:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/G-code}
    source:
      Ext: [.gcode, .nc, .tap]
      Fl: xhdl
      Require: ['\bG[0-9]+', '\bM[0-9]+', '\bX-?[0-9]', '\bY-?[0-9]']
      Bc: [[;, "\n"]]
  PARI/GP:
    description: |-
      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.
    links: {Reference: https://pari.math.u-bordeaux.fr/}
    source:
      Ext: [.gp]
      Str: [['"', '"', bse]]
      Fl: xmat
      Require: [\bfactor\(|\bnextprime\(|forprime|\bsqrt\(]
      Forbid: [\bclass\b|\bdef\b|\bfn\b]
      Bc: [[\\, "\n"]]
  Gnuplot:
    description: |-
      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.
    links: {Website: http://www.gnuplot.info/}
    source:
      Ext: [.gp, .gnuplot]
      Str: [['"', '"', bse]]
      Fl: xmdl
      Bc: [['#', "\n"]]
  GN:
    description: |-
      GN is a build configuration language developed by Google for defining
      and generating build files, primarily used with the Ninja build
      system. It is used in large-scale projects such as Chromium to
      describe build targets, dependencies, and toolchain configurations in
      a concise and declarative manner. GN files are evaluated to produce
      Ninja build files that drive compilation and linking.
    links: {Website: https://gn.googlesource.com/gn/, Reference: https://chromium.googlesource.com/chromium/src/+/main/docs/gn.md}
    source:
      Ext: [.gn, .gni]
      Bc: [['#', "\n"]]
      Require: ['(?:target|executable|static_library|shared_library|import)\(']
      Co: [if(, if (, else if(, else if (, else(, else (, '|| ', '&& ', '!= ', '== ']
      Fl: xbld
  GlimmerTS:
    description: |-
      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.
    links: {Website: https://glimmerjs.com/}
    source:
      Ext: [.gts]
      Like: C-like
      Fl: xtpl
  GlimmerJS:
    description: |-
      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.
    links: {Website: https://glimmerjs.com/}
    source:
      Ext: [.hbs]
      Like: XML-like
      Fl: xtpl
      Require: ['@[A-Za-z]|\bthis\.[A-Za-z]|<[A-Z][A-Za-z0-9.:]*[\s/>]|\{\{on\b|\{\{fn\b|\{\{outlet\b|\{\{component\b']
  Handlebars:
    description: |-
      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.
    links: {Website: https://handlebarsjs.com/}
    source:
      Ext: [.hbs, .handlebars]
      Bc: [['{{!--', '--}}']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
  Hack:
    description: |-
      Hack is a statically typed programming language for HHVM that evolved
      from PHP. It adds a type system, async programming support, collections,
      generics, shapes, and other modern language features while retaining
      familiar PHP-style variables, C-family control flow, and class syntax.
      Hack programs are commonly used for web services and large server-side
      applications that rely on HHVM's runtime and static analysis tooling.
    links: {Reference: https://docs.hhvm.com/hack/, Repository: https://github.com/facebook/hhvm}
    base:
      Like: C-like
      St: ;
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'switch ', 'while ', 'do ', 'else ', 'try ', 'catch ', 'async ', 'await ', 'concurrent ', 'using ', '|| ', '&& ', '!== ', '=== ', '!= ', '== ', '?? ', '?:']
    variants:
      native extension:
        Ext: [.hack]
      legacy header:
        Ext: [.hh, .hhi, .php]
        Require: ['^<\?hh(?:\s|$)']
  C++ Header:
    description: |-
      C++ headers are interface files used in C programs to declare functions,
      types, macros, constants, classes, and external variables shared across
      multiple translation units. They are incorporated into source files
      through the C++ preprocessor include directive and serve as the primary
      mechanism for exposing library APIs and maintaining consistent
      declarations during compilation. Header files are widely used in both
      system libraries and application code to separate interface
      definitions from implementation.
    source:
      Ext: [.hpp, .hxx, .hh]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: ign|xcpp|eur
  PHP:
    description: |-
      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.
    links: {Reference: https://www.php.net/manual/en/langref.php}
    source:
      Ext: [.php, .php3, .php4, .php5, .php7]
      She: [php, php5]
      Like: C-like
      St: ;
      Str: [['"', '"', ml|bse], ["'", "'", ml|bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [['#', "\n"]]
  Madlang:
    description: |-
      Madlang is a Haskell-based DSL. It is intended to explore
      computational creativity and provide an easy way to get started
      with generative literature.
    links: {Repository: https://github.com/vmchale/madlang/blob/master/test/Demo.hs}
    source:
      Ext: [.hs]
      Like: "Haskell-like"
      Require: ["Madlibs"]
      Fl: xdsl
  Haskell:
    description: |-
      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.
    links: {Reference: https://www.haskell.org/onlinereport/haskell2010/}
    source:
      Ext: [.hs]
      Like: Haskell-like
      Str: [['"', '"']]
      Co: ['if ', 'then ', 'else ', '|| ', '&& ', '/= ', '== ', 'case ', 'otherwise ', 'wildcard ', 'do {']
  HTML EEx:
    description: |-
      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.

      HTML EEx files are not reliably distinguishable from HEEx (Phoenix
      LiveView) template pages, and may be misreported as them.

      This is a different language from EEx which is a more general
      Elixir templating system.
    links: {Reference: https://hexdocs.pm/eex/EEx.html}
    source:
      Ext: [.html.eex, .heex]
      Str: [[<%, '%>', ml]]
      Fl: xtpl
      Require: [<%#]
      Bc: [[<%#, "\n"]]
  HEEx:
    description: |-
      HEEx (aka Phoenix LiveView) templates are server-rendered markup files
      used by the Phoenix web framework for the Elixir programming
      language. They combine HTML with embedded Elixir expressions to
      generate dynamic user interfaces that update in real time through a
      persistent server connection. The templates are compiled and rendered
      on the server, allowing interactive web applications to be built with
      minimal client-side JavaScript.

      HEEx pages are not reliably distinguishable from HTML EEx template
      and may be misreported as them.
    links: {Website: https://hexdocs.pm/phoenix_live_view/, Repository: https://github.com/phoenixframework/phoenix_live_view}
    source:
      Ext: [.heex, .leex]
      Like: XML-like
      Co: ['case ', 'cond ', 'if ', 'for ', 'with ', 'try ', 'catch ', 'rescue ', 'else ', 'and ', 'or ', 'not ', '!= ', '== ', '|| ', '&& ', '|> ']
      Fl: xtpl
      Require: [<%=|<% |<.live_component|phx-click=|phx-change=|phx-submit=]
  SWIG:
    description: |-
      SWIG interface files define bindings from C/C++ APIs to higher-level
      languages.
    links: {Reference: https://www.swig.org/Doc.html}
    base:
      Like: C-like
      St: ;
      Fl: xcpp|xtrn
    variants:
      source:
        Ext: [.swg, .swig]
      inclusion:
        Ext: [.i]
        Require: ['%{|%module']
  Yorick:
    description: |-
      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.
    links: {Reference: https://dhmunro.github.io/yorick-doc/qref/qrlang00.html}
    source:
      Ext: [.i]
      Like: C-like
      St: ;
      Require: ['func ']
  Slice:
    description: |-
      Slice is an interface definition language used by the Ice middleware
      platform to define object interfaces, data types, and exceptions for
      distributed applications. It enables language-neutral specification of
      services that can be mapped to multiple programming languages for
      remote procedure calls and object communication.
    links: {Reference: https://doc.zeroc.com/ice/latest/slice, Repository: https://github.com/zeroc-ice/ice}
    source:
      Ext: [.ice]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', ml|bse], ["'", "'", ml|bse]]
      Require: [\bmodule\b|\binterface\b|\bclass\b|\bstruct\b|\benum\b]
      Fl: xidl
  IPL-V:
    description: |-
      Information Processing Language is an early family of symbolic
      list-processing languages developed in the 1950s for artificial
      intelligence research; also cited as IPL. It introduced concepts
      such as dynamic memory allocation, list structures, and symbolic
      manipulation, and was used in foundational AI programs including the
      Logic Theorist. Its authors abandoned it for Lisp as soon as they
      became aware of Lisp.
    links: {Introduction: https://en.wikipedia.org/wiki/Information_Processing_Language}
    source:
      Ext: [.ipl]
      Fl: xdead
      Require: ['\b(?:H[0-9]+|W[0-9]+|[A-Z][0-9]+|9-[0-9]+)\b', '\b(?:SYMB|LINK|P|Q)\b']
  Julia-like:
    source:
      Bc: [['#=', =#], ['#', "\n"]]
      Str: [['"""', '"""', bse|ml], ["'''", "'''", ml], ['"', '"', bse]]
  Turing.jl:
    description: |-
      Turing.jl is a probabilistic programming system implemented in Julia
      that allows statistical models to be expressed directly as
      programs. Models describe random variables and their probabilistic
      relationships, and the system performs inference to estimate unknown
      quantities from observed data. It is designed to integrate
      with the broader Julia ecosystem so that probabilistic models can
      interoperate with scientific computing, numerical analysis, and
      data-processing tools available in the language.

      Not to be confused with the extinct educational language Turing.
    links: {Website: https://turinglang.org/, Repository: https://github.com/TuringLang/Turing.jl}
    source:
      Ext: [.jl]
      Like: Julia-like
      Require: ['@model\b|\b(Normal|Bernoulli|Poisson|Gamma|Beta|Uniform|MvNormal)\b']
  Julia:
    description: |-
      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.
    links: {Reference: https://docs.julialang.org/en/v1/manual/}
    source:
      Ext: [.jl]
      Like: Julia-like
      Co: ['for ', for(, 'if ', if(, 'while ', 'else ', 'elseif ', elseif(, 'try ', 'catch ', 'finally ', '|| ', '&& ']
  JCL:
    description: |-
      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.
    links: {Reference: "https://www.ibm.com/docs/en/zos/latest?topic=guide-job-control-language"}
    source:
      Ext: [.jcl, .job]
      Co: [' IF', ' THEN', ' ELSE', ' PROC=', ' PGM=', ' DD ', ' EXEC ', ' JOB ', ' COND=', ' INCLUDE', ' PEND']
      Fl: xdsl|xprop
      Require: [^(//|EXEC)]
      Bc: [[^//*, "\n"]]
  WISE Jobfile:
    description: |-
      WISE Jobfile is the configuration file format used by the W.I.S.E.
      fire behavior modeling system to describe simulation runs, including
      input data, environmental parameters, and output controls. It encodes
      the setup for wildfire spread calculations and related analyses within
      the W.I.S.E. workflow.
    links: {Website: https://wise.firelab.org/, Reference: https://wise.readthedocs.io/}
    source:
      Ext: [.job]
      Like: INI
      Require: ['^\[']
      Fl: xcfg
  CloudFormation (JSON):
    description: |-
      CloudFormation (JSON) is the JSON serialization of the AWS
      CloudFormation template language used to define and provision cloud
      infrastructure as code. It expresses resources, parameters, mappings,
      and dependencies that are processed by the CloudFormation service to
      create and manage stacks of AWS resources.
    links: {Website: https://aws.amazon.com/cloudformation/, Reference: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html}
    source:
      Ext: [.json]
      Like: JSON-like
      Co: ['!GetAtt', '!Sub', '!Select', '!Equals', '!If', 'DependsOn:', '!Select', '!Equals', '!If', 'Fn::If', 'Fn::And', 'Fn::Equals', 'Fn::Not', 'Fn::Or', 'Fn::Base64', 'Fn::Cidr', 'Fn::FindInMap', 'Fn::GetAtt', 'Fn::GetAZs', 'Fn::ImportValue', 'Fn::Join', 'Fn::Select', 'Fn::Split', 'Fn::Sub', 'Fn::Transform']
      Fl: xcfg
      Require: [\b(Resources|AWSTemplateFormatVersion|Parameters|Mappings|Conditions|Outputs|Transform|Description|Metadata)\n]
  JSON:
    description: |-
      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.
    links: {Reference: https://www.rfc-editor.org/rfc/rfc8259}
    source:
      Ext: [.json]
      Like: JSON-like
  Lex:
    aka: [LEX, lex]
    description: |-
      Lex is a lexical analyzer generator. A Lex specification defines
      patterns using regular expressions together with actions that execute
      when the patterns are matched. The tool translates the specification
      into source code implementing a scanner that reads an input stream,
      identifies tokens, and executes the associated actions. Lex is
      commonly used together with parser generators such as Yacc, where the
      scanner produces tokens consumed by the parser. Compatible
      implementations and successors, such as Flex, are widely used in
      compiler construction and text processing systems.
    links: {Introduction: https://westes.github.io/flex/manual/, Reference: https://pubs.opengroup.org/onlinepubs/7908799/xcu/lex.html}
    source:
      Ext: [.l]
      Like: C-like
      St: ;
      Fl: lex|xcpp
      Require: ['%{|%%|%}']
  JFlex:
    description: |-
      JFlex is a lexical analyzer generator for Java. JFlex specification
      files describe scanner user code, options, declarations, lexical
      states, macros, regular-expression rules, and Java actions in sections
      separated by %% markers, then generate Java lexer source from those
      specifications.
    links: {Website: https://www.jflex.de/, Manual: https://jflex.de/manual.html}
    source:
      Ext: [.jflex, .jlex, .lex, .flex]
      Bc: [[/*, '*/', cnest], [//, "\n"]]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Require: ['^\s*%%\s*$', '^\s*%(?:class|unicode|public|cup|cupdebug|line|column|char|byaccj|standalone|switch|table|pack|7bit|8bit|16bit|caseless|ignorecase|integer|int|intwrap|function|type|yylexthrow|implements|extends|ctorarg|initthrow|eofthrow|state|xstate)\b|^\s*%(?:init|eof|eofval)\{|^\s*%\{|^\s*[A-Za-z_][A-Za-z0-9_]*\s*=|^\s*(?:<[^>\n]+>|<<EOF>>)']
      Co: ['%state ', '%xstate ', '%cup ', '%line ', '%column ', '<<EOF>>', '|', '?', '*', '+', '{', '}']
      Fl: xpld
  Literate Haskell:
    description: |-
      Literate Haskell is a syntax variant that supports embedding
      code in its documentation by ignoring all program lines
      not led with a ">".
    links: {Reference: https://www.haskell.org/onlinereport/literate.html}
    source:
      Ext: [.lhs]
      Require: [^>]
      Fl: lit
  Literate Idris:
    description: |-
      Literate Idris is a syntax variant that supports embedding
      code in its documentation by ignoring all program lines
      not led with a ">".
    links: {Reference: https://idris2.readthedocs.io/en/latest/reference/literate.html}
    source:
      Ext: [.lidr]
      Require: [^>]
      Fl: lit
  Menhir:
    description: |-
      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.
    links: {Reference: https://gallium.inria.fr/~fpottier/menhir/}
    source:
      Ext: [.mly]
      Bc: [[(*, '*)', cnest]]
      Str: [['"', '"', bse]]
      Fl: xpld
      Require: ['%token|%start|%%']
  ML:
    description: |-
      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.
    links: {Website: https://smlfamily.github.io/}
    source:
      Ext: [.ml, .mll, .mly]
      Like: Pascal-like
      Str: [['"', '"', bse]]
  Miranda:
    description: |-
      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.
    links: {Reference: https://www.cs.kent.ac.uk/people/staff/dat/miranda/}
    source:
      Ext: [.m]
      Str: [['"', '"', bse]]
      Fl: xdead
      Require: ['::|where|otherwise']
      Forbid: ['@interface|@implementation|%|\^']
      Bc: [['||', "\n"]]
  MATLAB-like:
    source:
      Bc: [['%{', '%}', cnest], ['%', "\n"]]
      Str: [["'", "'"]]
      Fl: xssep|xmat
      St: ;
      Sb: if|for|while|switch|try|function|classdef|parfor|spmd
      Eb: end
      Require: [^\s*function\b|^\s*end\b|^\s*%|\bendif\b|\bendfunction\b]
      Forbid: ['#include']
  Octave:
    description: |-
      GNU Octave is a largely compatible open-source implementation of the
      MATLAB language.
    links: {Website: https://octave.org/}
    source:
      Ext: [.m]
      Bc: [['%{', '%}', cnest], ['%', "\n"], ['#', "\n"]]
      Str: [["'", "'"]]
      Fl: xssep|xmat
      St: ;
      Sb: if|for|while|switch|try|function|classdef|parfor|spmd
      Eb: end
      Require: ['^#!.*octave\b|^\s*#(?:\s|#|$)|\bendif\b|\bendfunction\b|\bendfor\b|\bendwhile\b|\bendswitch\b|\bunwind_protect\b|\bend_unwind_protect\b']
      Forbid: ['^\s*#(?:include|import)\b']
  MATLAB:
    description: |-
      MATLAB is a proprietary 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.

      The open-source Octave program provides very similar capabilities.
    links: {Introduction: https://en.wikipedia.org/wiki/MATLAB}
    source:
      Ext: [.m]
      Like: MATLAB-like
      Co: ['if ', 'elseif ', 'case ', 'otherwise ', try, 'for ', 'while ']
      Fl: xprop
  Mercury:
    description: |-
      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.
    links: {Website: https://mercurylang.org/}
    source:
      Ext: [.m]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Require: [^:-\s*module|^:-\s*pred|^:-\s*type|^:-\s*mode]
      Forbid: ['@interface|@implementation|%|\^']
      Bc: [['%', "\n"]]
  Objective C:
    aka: ['Objective-C', ObjC]
    description: |-
      Objective-C is a reflective, object-oriented programming language
      created in the early 1980s as ab upgrade of C. It adds
      Smalltalk-style message passing and dynamic runtime features to the C
      programming model, enabling late binding, runtime introspection, and
      category-based extension of existing classes. The language became
      widely used as the primary application programming language for
      NeXTSTEP and later Apple's macOS and iOS platforms, where it forms the
      historical foundation of the Cocoa and Cocoa Touch
      frameworks. Although largely superseded by Swift for new Apple
      platform development, it remains an important systems and framework
      language with a mature runtime and extensive legacy codebase.
    links: {Reference: https://clang.llvm.org/docs/ObjectiveCLanguage.html}
    source:
      Ext: [.m]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcpp
      Require: ['^#import\b|^#include\b|@[A-Za-z]|\b@interface\b|\b@implementation\b|\bprotocol\b']
  Objective C++:
    aka: ['Objective-C++', 'ObjC++']
    description: |-
      Objective-C++ is a hybrid programming language that allows
      Objective-C's dynamic object model and messaging system to be used
      directly alongside C++ classes, templates, and standard library
      facilities within the same source file. It was developed to support
      systems where C++ libraries needed to interoperate with Objective-C
      frameworks, particularly in Apple platform development. The language
      enables direct mixing of the two object systems, allowing C++ types to
      appear inside Objective-C classes and Objective-C objects to be used
      within C++ code, with the Clang and GCC compilers coordinating the
      semantics of both runtimes. It is commonly used in macOS and iOS
      codebases as a bridging layer between modern C++ engines or libraries
      and the Objective-C-based Cocoa and Cocoa Touch frameworks.
    links: {Introduction: https://gcc.gnu.org/onlinedocs/gcc/Objective-C-and-Objective-C_002b_002b.html}
    source:
      Ext: [.mm]
      Like: C-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xcpp
      Require: ['^#import\b|^#include\b|@[A-Za-z]|\b@interface\b|\b@implementation\b|\bprotocol\b']
  MUMPS:
    description: |-
      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.
    links: {Website: https://mumps.sourceforge.net/docs.html}
    source:
      Ext: [.mps, .m]
      Str: [['"', '"']]
      Require: ['\^[A-Za-z%]|\$[A-Za-z]+|^\s*[A-Za-z%][A-Za-z0-9]*\s']
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Bc: [[;, "\n"]]
  roff:
    description: |-
      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.
    links: {Reference: https://man7.org/linux/man-pages/man7/groff.7.html}
    source:
      Ext: [.me, .mm, .ms]
      Like: roff-like
      Fl: doc
  Metafont:
    description: |-
      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.
    links: {Website: https://tug.org/metafont.html}
    source:
      Ext: [.mf]
      St: ;
      Str: [['"', '"']]
      Fl: xmdl
      Require: ['%']
      Bc: [['%', "\n"]]
  Automake:
    description: |-
      Automake is a GNU build-system DSL used to generate portable
      "Makefile.in" templates that are later configured into Makefiles.
    links: {Reference: https://www.gnu.org/software/automake/manual/automake.html}
    source:
      Ext: [.am, .mf]
      Str: [['"', '"', ml]]
      Fl: xbld
      Bc: [['#', "\n"]]
  Motoko:
    description: |-
      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.
    links: {Reference: https://internetcomputer.org/docs/current/motoko/main/motoko}
    source:
      Ext: [.mo]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
      Fl: xctr
      Require: [\bactor\b|\bmodule\b|\basync\b|\bawait\b]
  Modelica:
    description: |-
      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.
    links: {Reference: https://specification.modelica.org/}
    source:
      Ext: [.mo]
      Like: C-like
      St: ;
      Fl: xmdl
  Nature:
    description: |-
      Nature is a general-purpose systems programming language and compiler
      designed for high-performance, safe, reliable, and cross-platform
      software. The project describes itself as emphasizing a strong static
      type system, native-code compilation without LLVM, concurrency
      primitives, and a self-developed toolchain and runtime.
    links: {Reference: https://nature-lang.org/docs/syntax, Repository: https://github.com/nature-lang/nature}
    source:
      Ext: [.n]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['`', '`', ml], ['"', '"', ml], ["'", "'", ml]]
      Require: ['^\s*(?:import|fn|var|const|type)\b', '\bfn\s+[A-Za-z_][A-Za-z0-9_]*\s*\(']
      Co: ['go ', 'for ', for(, 'if ', if(, 'catch ', catch(, 'else ', 'else{', 'match ', match(, 'match{', 'select ', 'select{', '|| ', '&& ', '!= ', '== ']
  Nemerle:
    description: |-
      Nemerle is a statically typed programming language for the .NET
      platform that combines functional and object-oriented programming
      features with an extensive macro system.
    links: {Repository: https://github.com/rsdn/nemerle}
    source:
      Ext: [.n]
      Like: C-like
      St: ;
      Str: [['"', '"', bse]]
      Require: [\bdef\s+\w+\s*\(, <-, \bmatch\b]
  Nunjucks:
    description: |-
      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.
    links: {Repository: https://mozilla.github.io/nunjucks/}
    source:
      Ext: [.njk, .nunjucks]
      Like: XML-like
      Fl: xtpl
      Require: ['\{\{|\{%|\{#']
      Forbid: [<cf|<jsp|<#]
  occam:
    description: |-
      occam is a concurrent programming language designed for the
      Transputer architecture.  It emphasizes communicating sequential
      processes and deterministic parallelism.
    links: {Reference: https://www.cs.kent.ac.uk/projects/ofa/kroc/}
    source:
      Ext: [.occ]
      Str: [['"', '"']]
      Fl: xdead
      Require: [^--|PROC, SEQ]
      Bc: [[//, "\n"]]
  Delphi:
    aka: [Object Pascal]
    description: |-
      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.

      Open-source Delphi-compatible implementations exist in Free Pascal and
      Lazarus.
    links: {Website: https://www.embarcadero.com/products/delphi}
    base:
      Like: Pascal-like
      Forbid: ['module\s|\bvar\s*=']
    variants:
      source:
        Ext: [.pas, .dws]
        Require: [\bunit\b|\binterface\b|\bimplementation\b|\bclass\b]
      rootfile:
        Ext: [.dpr]
        Require: [\bprogram\b|\blibrary\b]
  Delphi Form:
    description: |-
      Delphi Form is a resource description format used by Delphi-compatible
      toolchains to represent visual components, properties, and layout of
      forms in Object Pascal applications. It is paired with Pascal source
      units and is processed by the toolchain to construct user interfaces at
      design time and runtime. Open-source readers and compilers for DFM
      files exist in Free Pascal.
    links: {Reference: https://www.freepascal.org/docs-html/current/fclres/dfmreader/index.html}
    source:
      Ext: [.dfm]
      Require: [^\s*object\s+\w+\s*:\s*\w+, ^\s*end\s*$]
      Fl: xidl
  Pascal:
    description: |-
      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.
    links: {Website: https://standardpascal.org/}
    base:
      Like: Pascal-like
      St: ;
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', 'AND ', 'OR ', 'IF ', 'ELSE ']
    variants:
      .pas extension:
        Ext: [.pas]
      .p or .inc module:
        Ext: [.p, .inc]
        Require: ['(?i)\bmodule\s+[A-Za-z]', '(?i)end\.\s*$']
      .p or .inc program:
        Ext: [.p, .inc]
        Require: ['(?i)\bprogram\s+[A-Za-z]', '(?i)\bbegin\b', '(?i)end\.\s*$']
      .p or .inc unit:
        Ext: [.p, .inc]
        Require: ['(?i)\bunit\s+[A-Za-z]', '(?i)\bprocedure\b|\bfunction\b|^\s*interface\s+|^\s*implementation\s+', '(?i)\bbegin\b', '(?i)end\.\s*$']
  POV-Ray SDL:
    description: |-
      POV-Ray SDL is the scene description language used by POV-Ray to
      describe scenes for rendering. Files define cameras, lights,
      geometric objects, object combinations, pigments, textures, media,
      global settings, declarations, macros, conditional parsing, loops,
      and reusable include files.
    links: {Reference: https://www.povray.org/documentation/view/3.7.0/224/, Comments: https://www.povray.org/documentation/view/3.7.0/227/, Include Files: https://wiki.povray.org/content/Reference%3AInclude_Directive, Strings: https://wiki.povray.org/content/Reference%3AStrings}
    source:
      Ext: [.pov]
      Files: [colors.inc, consts.inc, debug.inc, finish.inc, functions.inc, glass.inc, math.inc, metals.inc, rand.inc, shapes.inc, shapes2.inc, shapesq.inc, skies.inc, strings.inc, textures.inc, transforms.inc, woods.inc]
      Bc: [[/*, '*/', cnest], [//, "\n"]]
      Str: [['"', '"', bse]]
      Require: ['^\s*#(?:include|declare|local|macro|version|if|ifdef|ifndef|else|end|while|switch|case|range|break|default)\b|\b(?:camera|light_source|global_settings|background|sphere|box|cylinder|cone|plane|mesh|mesh2|union|difference|intersection|merge|object|texture|pigment|normal|finish|media)\s*\{']
      Co: ['#if ', '#ifdef ', '#ifndef ', '#else', '#switch ', '#case ', '#range ', '#while ', '#macro ', 'union ', 'difference ', 'intersection ', 'merge ', 'object ', 'texture ', 'pigment ']
      Fl: xmdl
  PEG:
    description: |-
      Parsing Expression Grammar is a formal grammar notation used to
      describe the syntax of programming languages and data formats through
      recognition-based rules. It defines parsing behavior using ordered
      choice and repetition operators, and is used as the foundation for
      parser generators and language tooling.
    links: {Reference: https://en.wikipedia.org/wiki/Parsing_expression_grammar}
    source:
      Ext: [.peg]
      Require: ['<-', '/', '\\*', '\\+', '\\?']
      Fl: xpld
  POP-11:
    description: |-
      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.
    links: {Website: https://poplogarchive.getpoplog.org/}
    source:
      Ext: [.p]
      Str: [['"', '"']]
      Fl: xdead
      Require: [define|printf]
      Bc: [[;, "\n"]]
  Pilot:
    description: |-
      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.
    links: {Repository: https://gitlab.com/esr/ieee-pilot}
    source:
      Ext: [.p]
      Fl: xdead
      Require: ['^\s*[ACEJMNRTU]\s*:\s']
      Bc: [[R, "\n"]]
  Picat:
    description: |-
      Picat is a multi-paradigm programming language that combines logic
      programming, functional programming, and scripting features. It was
      designed to support declarative modeling and efficient problem
      solving, particularly in areas such as constraint programming,
      planning, and combinatorial optimization. Picat programs are composed
      of predicates and functions written using rule-based definitions and
      pattern matching, and the language includes built-in support for
      tabling, constraint solving, and planning.
    links: {Website: https://picat-lang.org/, Repository: https://github.com/picat-lang/picat}
    source:
      Ext: [.pi, .picat]
      Bc: [['%', "\n"]]
      St: .
      Require: ['(?:import |table |=>|\?=>)']
      Co: ['do ', 'foreach ', foreach(, 'if ', if(, 'switch ', 'while ', while(, 'else ', '|| ', '&& ', '!= ', '== ']
  GDL:
    aka: ['GNU Data Language']
    description: |-
      GDL, the GNU Data Language, is a free and open-source implementation
      of the array-oriented IDL language used for scientific data analysis,
      visualization, image processing, and numerical research workflows. It
      is designed as an incremental compiler and data-analysis environment
      compatible with IDL and partially compatible with PV-WAVE, allowing
      many existing IDL programs and libraries to run without the proprietary
      RSI, Harris, or NV5 IDL runtime.
    links: {Website: https://gnudatalanguage.github.io/, Repository: https://github.com/gnudatalanguage/gdl, Reference: https://www.nv5geospatialsoftware.com/docs/Overview_of_IDL_Program.html}
    base:
      Bc: [[;, "\n"]]
      Str: [['"', '"'], ["'", "'"]]
      Fl: xmat
      Co: ['if ', 'then ', 'else ', 'for ', 'foreach ', 'while ', 'repeat ', 'case ', 'switch ', 'and ', 'or ', 'not ', 'eq ', 'ne ', 'lt ', 'le ', 'gt ', 'ge ', 'IF ', 'THEN ', 'ELSE ', 'FOR ', 'FOREACH ', 'WHILE ', 'REPEAT ', 'CASE ', 'SWITCH ', 'AND ', 'OR ', 'NOT ', 'EQ ', 'NE ', 'LT ', 'LE ', 'GT ', 'GE ']
    variants:
      executable script:
        She: [gdl, gnudl, gnudatalanguage]
      named program file:
        Ext: [.pro]
        Require: ['(?i)^\s*(?:pro|function)\s+[A-Za-z_][A-Za-z0-9_$]*\b']
      main-level program file:
        Ext: [.pro]
        Require: ['(?i)\b(?:endif|endfor|endforeach|endwhile|endrep|then\s+begin)\b', '(?i)\b(?:plot|print|read[a-z]*|write[a-z]*|where|findgen|fltarr|dblarr|indgen|n_elements|size)\b']
  qmake:
    aka: ['Qt Project']
    description: |-
      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.
    links: {Reference: https://doc.qt.io/qt-6/qmake-manual.html}
    source:
      Ext: [.pro, .pri]
      Fl: xbld
      Require: ['\bQT\s*\+?=|\bSOURCES\s*\+?=|\bHEADERS\s*\+?=|\bCONFIG\s*\+?=|\bTEMPLATE\s*=']
      Bc: [['#', "\n"]]
  Prolog:
    description: |-
      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.
    links: {Website: https://www.swi-prolog.org/}
    base:
      Bc: [[/*, '*/'], ['%', "\n"]]
      St: .
      Str: [['"', '"', bse], ["'", "'", bse]]
      Require: [':-|\bconsult\b|\bassert[a-z]*\b|\bretract[a-z]*\b']
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
    variants:
      legacy etensions:
        Ext: [.plog, .pro]
      common extension:
        Ext: [.pl]
        Forbid: ['^use|^#|\$[[:alpha:]]']
  Scallop:
    description: |-
      Scallop is a declarative programming language designed for
      differentiable logic programming and probabilistic reasoning. It
      allows developers to express logical relations and inference rules
      while integrating numerical learning methods commonly used in machine
      learning systems. The language is used in research on neuro-symbolic
      programming, where logical reasoning is combined with gradient-based
      optimization to support tasks such as knowledge extraction, structured
      prediction, and explainable AI.
    links: {Website: https://www.scallop-lang.org/, Repository: https://github.com/scallop-lang/scallop}
    source:
      Ext: [.scl]
      Like: Prolog
      Co: ['rel ', count(, sum(, prod(, min(, max(, exists(, forall(, '|| ', '&& ', '!= ', '== ', '>= ', '> ', '<= ', '< ']
  xBase-like:
    source:
      Str: [['"', '"']]
      Fl: xdsl
      Bc: [['*', "\n"], [REM, "\n"], [rem, "\n"]]
  Clipper:
    description: |-
      Clipper was a programming language and development system in the xBase
      family.  Open-source Harbour interprets the main .prg and .dbf
      files Clipper uses; Clipper has its own .ntx files which are
      textual index files.
    links: {Introduction: https://en.wikipedia.org/wiki/Clipper_(programming_language)}
    source:
      Ext: [.prg, .ch, .ntx]
      Like: xBase-like
      Require: [\bLOCAL\b, \bSTATIC\b, \bPROCEDURE MAIN\b]
      Co: ['for ', for(, 'if ', if(, 'do while ', 'while ', 'else ', 'elseif ', else(, 'switch ', 'case ', 'otherwise ', 'begin sequence ', 'end sequence ', begin sequence(, 'try ', 'catch ', 'finally ', '|| ', '&& ', '!= ', '== ']
      Fl: xdead
  dBase:
    description: |-
      dBase was a programming language and development system in the xBase
      family.  Open-source Harbour interprets the main .prg and .dbf
      files dBase uses; non-textual .mdx files that are database
      indexes might be found nearby.
    links: {Introduction: https://en.wikipedia.org/wiki/DBase}
    source:
      Ext: [.prg, .ch]
      Like: xBase-like
      Require: [\bUSE\b, \bAPPEND\b, \bREPLACE\b]
      Fl: xdead
  FoxPro:
    aka: [Visual FoxPro]
    description: |-
      FoxPro was a programming language and development system in the xBase
      family.  Open-source Harbour interprets the main .prg and .dbf
      files FoxPro uses; non-textual .cdx and .sdx files that are database
      indexes might be found nearby.
    links: {Reference: https://en.wikipedia.org/wiki/DBase}
    source:
      Ext: [.prg, .ch]
      Like: xBase-like
      Require: [\bLPARAMETERS\b, \bTHISFORM\b]
      Fl: xdead
  xBase:
    description: |-
      Source files and headers from the xBase family of
      database programming languages.  These derived from dBASE and were
      once widely used on microcomputers to build data-centric applications
      operating on DBF database files. Implementations included dBASE,
      Clipper, FoxPro, and Visual FoxPro. They provided compatible languages and
      tools that integrate query, data manipulation, and user-interface
      logic around the underlying database engine.

      Program files in this family (.prg and .ch) may be reported as dBase,
      Clipper, or FoxPro depending on what keyboards they contain. Related
      file extensions .ndx, .cdx, and .sdx are non-textual index
      files. This is a fallback category for files that don't

      While these formats have been superseded by SQL, Harbor and xHarbour
      are open-source programs that can be used to work with and recover
      the data.
    links: {Reference: https://en.wikipedia.org/wiki/XBase}
    source:
      Ext: [.prg, .ch]
      Like: xBase-like
  Portable Standard Lisp:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/Portable_Standard_Lisp}
    source:
      Ext: [.psl]
      Like: Lisp-like
      Str: [['"', '"', bse]]
      Fl: xdead
      Require: [\(defun|\(setq|\(lambda|\(cond]
      Forbid: [\bmodule\b|\bclass\b|\bfn\b]
  PSL:
    description: |-
      PSL (Property Specification Language) is a formal assertion DSL for
      hardware/system property checking. It standardized under IEEE 1850.

      Reference::
      https://www.accellera.org/downloads/standards/psl

      Note that a couple of other languages named "PSL" have
      existed: Portable Standard Lisp, Profile Scripting Language,
      and Probabilistic Soft Logic.
    source:
      Ext: [.psl]
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
      Bc: [[--, "\n"]]
  OpenQASM:
    description: |-
      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.
    links: {Website: https://openqasm.com/}
    source:
      Ext: [.qasm]
      Like: C-like
      St: ;
      Co: ['for ', 'if ', if(, 'switch ', switch(, 'while ', while(, 'else ', else(, '|| ', '&& ', '!= ', '== ']
      Fl: xdsl
      Require: [^OPENQASM]
  Rebol:
    description: |-
      REBOL (Relative Expression-Based Object Language) is a scripting
      language designed for network communication and data exchange.
    links: {Website: https://www.rebol.com/}
    source:
      Ext: [.r, .r3, .reb, .rebol]
      Str: [['"', '"', ml]]
      Require: [REBOL]
      Co: ['for ', for(, 'forever ', 'foreach ', 'forall ', 'forskip ', 'loop ', 'repeat ', 'if ', if(, 'either ', either(, 'switch ', switch(, 'switch/default ', switch/default(, 'case ', case(, 'case/all ', case/all(, 'while ', while(, 'until ', until(, 'or ', 'and ', '<> ', '= ']
      Bc: [[comment, "\n"]]
  R:
    description: |-
      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.
    links: {Website: https://cran.r-project.org/}
    source:
      Ext: [.r]
      She: [Rscript]
      Str: [['"', '"', bse]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xmat
      Bc: [['#', "\n"]]
  rc:
    description: |-
      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.
    links: {Reference: https://9p.io/sys/doc/rc.html, Unix port: https://github.com/benavento/rc}
    source:
      Ext: [.rc]
      She: [rc]
      Like: Shell-like
  Redex:
    description: |-
      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.
    links: {Website: https://docs.racket-lang.org/redex/}
    source:
      Ext: [.rkt]
      Like: Lisp-like
      Fl: xdsl
      Require: [define-language|reduction-relation|term]
  Racket:
    description: |-
      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.
    links: {Website: https://docs.racket-lang.org/}
    source:
      Ext: [.rkt]
      She: [racket]
      Like: Lisp-like
      Bc: [['#|', '|#', cnest]]
      Co: [(if, (cond, '[else', (and, (or, (for, '#:when', '#:unless', '#:break', '#:final', (do, (when, (unless, (shared, (case]
  Chisel:
    description: |-
      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.
    links: {Website: https://www.chisel-lang.org/}
    source:
      Ext: [.scala]
      Like: C-like
      Str: [['"""', '"""', ml]]
      Fl: xhdl
      Require: [chisel3|Chisel]
  Scala:
    description: |-
      Scala is a statically typed programming language that blends
      object-oriented and functional programming paradigms, running
      primarily on the Java Virtual Machine (JVM).
    links: {Specification: https://www.scala-lang.org/files/archive/spec/2.12/}
    source:
      Ext: [.scala]
      Like: C-like
      Str: [['"""', '"""', ml]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', '>= ', '> ', '<= ', '< ']
  SaltStack:
    description: |-
      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.
    links: {Reference: https://docs.saltproject.io/en/latest/topics/tutorials/starting_states.html}
    source:
      Ext: [.sls]
      Like: YAML-like
      Fl: xcfg
      Require: ["<!--"]
      Forbid: [defun]
  Scheme:
    description: |-
      Scheme is a broad class of Lisp dialects distinguished by lexical
      scoping, first-class continuations, and a false boolean 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.
    links: {Reference: https://www.gnu.org/software/guile/manual/}
    source:
      Ext: [.scm, .sps, .sls, .sld]
      Like: Lisp-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  HOL4:
    description: |-
      HOL4 is an interactive theorem prover for higher-order logic,
      descended from the original LCF tradition and developed as part of
      the HOL family of proof assistants. It provides a small trusted
      kernel implementing inference rules, with all higher-level proof
      automation constructed in Standard ML, ensuring soundness by
      construction. HOL4 is used for formal specification and
      machine-checked proofs of mathematical theorems, algorithms, and
      hardware or software systems, and is widely applied in formal
      methods research and verification.
    links: {Website: https://hol-theorem-prover.org/, Repository: https://github.com/HOL-Theorem-Prover/HOL}
    source:
      Ext: [.sml, .sig, .Script]
      Like: "ML-like"
      Fl: xmat
      Require: ["\bTheorem\b", "\bDefinition\b", "\bDatatype\b", "\bInductive\b", "\bProof\b", "\bQED\b", "\bstore_thm\b", "\bnew_theory\b", "\bexport_theory\b", "\bREWRITE_TAC\b", "\bSIMP_TAC\b", "\bMETIS_TAC\b", "\bASM_REWRITE_TAC\b", "\bCases_on\b", "\bInduct_on\b"]
  SML:
    aka: ['Standard ML']
    description: |-
      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.
    links: {Website: https://smlfamily.github.io/}
    source:
      Ext: [.sml]
      Like: ML-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  SparForte:
    description: |-
      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.
    links: {Website: https://sparforte.com/}
    source:
      Ext: [.sp]
      Like: Ada
      Str: [['"', '"']]
      Require: [^--|\bprocedure\b|\bbegin|\bdeclare\b]
  SPICE:
    description: |-
      SPICE is a circuit-netlist language for analog/mixed-signal circuit
      simulation (the simulator family, not the modern systems language).
    links: {Reference: https://ngspice.sourceforge.io/docs.html}
    source:
      Ext: [.sp, .spi, .cir, .ckt, .net]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xhdl
      Bc: [['*', "\n", sol]]
  Terra:
    description: |-
      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.
    links: {Website: https://terralang.org/}
    source:
      Ext: [.t, .terra]
      Like: C-like
      Str: [['"', '"', bse]]
      Fl: xdsl
      Require: [\bterra\b]
  Turing:
    description: |-
      Turing is an extinct programming language developed at the University
      of Toronto for teaching computer science concepts. Turing was widely
      used in computer science education, particularly in Canadian schools,
      as a platform for introducing programming fundamentals and algorithmic
      thinking.

      Not to be confused with Turing.jl, a language for probabilistic
      inference.
    links: {Website: https://en.wikipedia.org/wiki/Turing_(programming_language)}
    source:
      Ext: [.t]
      Str: [['"', '"']]
      Fl: xdead
      Require: ["^%", "function ", "end "]
      Bc: [['%', "\n"]]
  Wish:
    description: |-
      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.
    links: {Reference: https://www.tcl.tk/man/tcl/TkCmd/wish.htm}
    source:
      Ext: [.tcl]
      Like: Tcl-like
      Require: [wish]
  Tcl:
    aka: [TCL, 'Tcl/Tk']
    description: |-
      Tcl (Tool Command Language) is a dynamic scripting language commonly
      used for embedding in applications and for writing GUI programs using
      the Tk toolkit.
    links: {Website: https://www.tcl.tk/}
    source:
      Ext: [.tcl]
      She: [tcl, tclsh]
      Like: Tcl-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Expect:
    description: |-
      Expect is a scripting language used to automate interactive programs
      such as command-line tools and network logins.
    links: {Website: https://core.tcl-lang.org/expect/}
    source:
      Ext: [.exp]
      Like: Tcl-like
      Require: ['^\s*\{|\{\s*$', '^\s*}|};?\s*$', '\bproc\b|\bif\b|\[.*\]|^\s*expect\s']
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  ConTeXt:
    description: |-
      A document preparation system built on top of the TeX typesetting
      engine, providing an integrated and programmable environment for
      high-quality typesetting and structured document production.
    links: {Website: https://wiki.contextgarden.net/, Reference: https://www.pragma-ade.nl/general/manuals/contextref.pdf, Repository: https://github.com/contextgarden/context}
    base:
      Bc: [[\startcomment, \stopcomment], ['%', "\n"]]
      Fl: doc
    variants:
      native extension:
        Ext: [.tex]
        Require: [=start|=stop]
      fallback:
        Ext: [.mkiv, .mkxl]
  LaTeX:
    description: |-
      LaTeX is a document preparation system built on the TeX typesetting
      engine that provides structured markup for producing high-quality
      technical and scientific documents. Authors write documents using
      commands that describe the logical structure of the text—such as
      sections, figures, tables, citations, and mathematical formulas—rather
      than specifying visual formatting directly. Documents are processed by
      a typesetting engine that interprets the markup, applies document
      classes and packages, and produces formatted output suitable for
      publication. The system is widely used for academic writing,
      especially in fields that require complex mathematical notation and
      precise control over document structure.
    links: {Website: https://www.latex-project.org}
    source:
      Ext: [.tex, .sty]
      Fl: doc
      Require: ['\\documentclass\b|\\begin{document}|\\usepackage\b']
      Bc: [['%', "\n"]]
  TeX:
    description: |-
      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.
    links: {Website: https://www.tug.org/}
    source:
      Ext: [.tex, .sty]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: doc
      Bc: [['%', "\n"]]
  TL:
    description: |-
      TL is a schema language used by the Telegram messaging platform to
      define remote procedure call interfaces and data serialization
      formats. A TL schema describes data structures and API methods using
      declarative constructor definitions, allowing Telegram clients and
      servers to exchange strongly typed binary messages. The language is
      used to generate code for multiple programming languages and forms the
      basis of the Telegram MTProto API specification.
    links: {Reference: https://core.telegram.org/mtproto/TL, Repository: https://github.com/tdlib/td/blob/master/td/generate/scheme/telegram_api.tl}
    source:
      Ext: [.tl, .t]
      St: ;
      Require: ['---functions---', 'vector {t:Type}', ' = Vector ', '# [ t ] = Vector']
      Bc: [[//, "\n"]]
      Fl: xidl
  TL-Verilog:
    aka: [TLV, 'Transaction-Level Verilog']
    description: |-
      TL-Verilog is the Verilog/SystemVerilog member of the TL-X family of
      transaction-level hardware description language extensions. Files
      combine native SystemVerilog regions with TL-X regions that describe
      behavioral hierarchy, pipelines, pipeline stages, validity, state,
      timing alignment, signals, and assignments that are translated to
      Verilog or SystemVerilog RTL.
    links: {Website: https://www.redwoodeda.com/tl-verilog, Specification: https://docs.google.com/document/d/1vJy2yIHwBjkUGQaS9_iAnKoiZDoMaGvG81oUXNCt_uA/pub, Examples: https://github.com/stevehoover/makerchip_examples}
    source:
      Ext: [.tlv]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', bse]]
      St: ;
      #Require: ['^\s*\\(?:m[45]_)?TLV_version\s+\S+\s*:\s*tl-x\.org\b|^\s*\\TLV\b']
      Co: ['\TLV', '\SV', '\SV_plus', '\TLV_version', '|', '@', '?$', '$ANY', '$RETAIN', '>>', '<= ', '= ', 'when ', 'else ', '\always_comb']
      Fl: xhdl
  Teal:
    description: |-
      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.
    links: {Website: https://teal-language.org/}
    source:
      Ext: [.tl]
      Like: lua
      Require: ['local type ', 'global type ', 'local record ', 'global record ', 'local enum ']
      Co: ['loop:', retsub, 'callsub ', '&&', ==, '||', <=, '>=']
  JSP Tag Library Definition:
    description: |-
      JSP Tag Library Definition is an XML-based descriptor format used in
      JavaServer Pages to declare custom tag libraries, including their
      identifiers, versions, and available tags. It enables JSP containers
      to recognize and bind custom tags to their corresponding handler
      classes for use in JSP pages.
    links: {Reference: https://jakarta.ee/specifications/tags/}
    source:
      Ext: [.tld]
      Like: XML-like
      Require: ['<\s*taglib\b', '<\s*(?:tag|uri|short-name|tlib-version)\b']
      Fl: xidl
  Smarty:
    description: |-
      Smarty is a templating system used to generate presentation output by
      combining markup with embedded directives and variable
      substitutions. It supports structural composition through reusable
      components and layout inheritance, enabling separation between
      application logic and rendered output.

      Reference::
      HTML: https://www.smarty.net/docs/en/
    links: {Repository: https://github.com/smarty-php/smarty}
    source:
      Ext: [.tpl]
      Bc: [['{*', '*}']]
      Str: [['"', '"', ml], ["'", "'", ml]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', 'include ']
      Fl: xtpl
      Require: ['\{(?:\*|\$|/?(?:if|foreach|for|while|block|include|extends|assign|capture|literal|strip)\b)']
  Pan:
    description: |-
      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.
    links: {Reference: https://www.quattor.org/quattor/pan-language.html}
    source:
      Ext: [.pan, .tpl]
      St: ;
      Fl: xdsl
      Bc: [['#', "\n"]]
  QtLinguist:
    description: |-
      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.
    links: {Reference: https://doc.qt.io/qt-6/qtlinguist-index.html}
    source:
      Ext: [.ts]
      Like: XML-like
      Fl: xdsl
      Require: [<TS\b|<context>|<message>|<source>|<translation>]
  TypeScript:
    description: |-
      TypeScript extends JavaScript with optional static typing, interfaces,
      and other language features intended to support large-scale software
      development. Programs are compiled into standard JavaScript so they
      can run in existing JavaScript environments such as web browsers and
      server-side runtimes. TypeScript is widely used for building complex
      web applications and tooling, and has become a common development
      language for modern JavaScript ecosystems.
    links: {Website: https://www.typescriptlang.org/, Reference: http://www.typescriptlang.org/docs/handbook/basic-types.html, Repository: https://github.com/microsoft/TypeScript}
    source:
      Ext: [.ts, .mts, .cts]
      Like: JavaScript-like
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '!== ', '== ', '=== ', 'case ', 'case(', '?.', '?? ', '??= ']
  V:
    description: |-
      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.
    source:
      Ext: [.v]
      Like: C-like
      Str: [['"', '"', bse]]
      Require: [\bfn\b|\bstruct\b|\bmodule\b|\bpub\b]
      Forbid: [\bmodule\b.*;|\bendmodule\b|\bwire\b|\bassign\b]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  Virgil:
    description: |-
      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.
    links: {Reference: http://compilers.cs.ucla.edu/virgil/}
    source:
      Ext: [.v]
      Like: C-like
      St: ;
      Require: [\bclass\b|\bcomponent\b|\bmethod\b|\bnew\b]
      Forbid: [\bmodule\b|\bendmodule\b|\bProof\b|\bQed\b]
  Rocq:
    aka: [Coq]
    description: |-
      Rocq (formerly known as Coq) is a formal proof language used for
      reasoning about programs and mathematical systems.
    links: {Website: https://rocq-prover.org/}
    source:
      Ext: [.v]
      Bc: [[(*, '*)', cnest]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xmat
      Require: [Qed|Proof|Theorem|Fixpoint]
  Verilog:
    description: |-
      Verilog is a hardware description language used to model digital
      systems such as integrated circuits. Its successor is SystemVerilog.
    links: {Website: https://www.accellera.org/downloads/standards/verilog}
    source:
      Ext: [.v, .vh]
      Bc: [[/*, '*/'], [//, "\n"]]
      St: ;
      Str: [['"', '"']]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xhdl
  Logos:
    description: |-
      Logos is a domain-specific language used for method hooking and
      runtime modification in Objective-C environments, most commonly within
      Theos-based development workflows. It provides a concise way to
      intercept and extend existing class behavior without directly
      modifying original source code, enabling dynamic alteration of
      application behavior.
    links: {Reference: https://theos.dev/docs/logos, Repository: https://github.com/theos/logos}
    source:
      Ext: [.xm, .xi, .x]
      Bc: [[/*, '*/'], [//, "\n"]]
      Str: [['"', '"', ml], ["'", "'", ml]]
      Require: [^\s*%hook\b, ^\s*%end\b, ^\s*%orig\b]
      Fl: xdsl
  Alex (Haskell):
    description: |-
      This Alex is a parser generator for Haskell.

      Reference::
      https://haskell-alex.readthedocs.io/en/latest/index.html

      //There are a couple of other languages named "Alex";
      //An experimental language built at Cornell in the 1980s,
      //and an esolang.
    source:
      Ext: [.x]
      Str: [['"', '"']]
      Bc: [[--, "\n"]]
      Fl: xpld
  ITU SDL:
    description: |-
      Specification and Description Language is a formal modeling language
      standardized by the ITU for describing and analyzing reactive and
      distributed systems, particularly in telecommunications. It provides
      both graphical and textual representations for defining processes,
      communication via signals, and state-based behavior, enabling precise
      specification of system interactions and execution semantics.
    links: {Reference: https://www.itu.int/rec/T-REC-Z.100/en}
    source:
      Ext: [.sdl]
      Fl: xmdl
      Require: [\bprocess\b, \bsignal\b, \bstate\b, \binput\b, \boutput\b, \bnextstate\b]
      Bc: [[--, "\n"]]
  JSF:
    description: |-
      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.
    links: {Reference: https://jakarta.ee/specifications/faces/}
    source:
      Ext: [.jsf, .xhtml]
      Like: XML-like
      Fl: xtpl
      Require: ['xmlns:h=|xmlns:f=|xmlns:ui=|<h:|<f:|<ui:']
  XHTML:
    description: |-
      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.
    links: {Website: https://www.w3.org/TR/xhtml1/}
    source:
      Ext: [.xhtml, .xht]
      Like: XML-like
      Fl: doc
  Systemd:
    description: |-
      Systemd unit files are declarative configuration files used to
      describe and manage system services, resources, and lifecycle events
      under the systemd init system. They organize configuration into named
      sections and key-value assignments, allowing the system manager to
      coordinate activation, dependencies, and state transitions across
      system components.
    links: {Reference: https://www.freedesktop.org/software/systemd/man/systemd.unit.html, Repository: https://github.com/systemd/systemd}
    source:
      Like: INI
      Ext: [.automount, .device, .link, .mount, .path, .scope, .service, .slice, .socket, .swap, .target, .timer]
      Require: ['^\s*\[[A-Za-z]+\]', '^\s*[A-Za-z][A-Za-z0-9]*=']
      Fl: xcfg
      Bc: [['#', "\n"]]
  XML-DocBook:
    description: |-
      DocBook is an XML vocabulary designed for writing technical
      documentation such as manuals and books.
    links: {Website: https://docbook.org/}
    source:
      Ext: [.xml]
      Like: XML-like
      Require: [XML-DocBook]
      Fl: doc
  XML:
    description: |-
      XML (Extensible Markup Language) is a markup language for encoding
      structured documents and data.  It provides a general framework for
      defining custom document formats.
    links: {Website: https://www.w3.org/XML/}
    source:
      Ext: [.xml]
      Like: XML-like
      Fl: xser
  Happy:
    description: |-
      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.
    links: {Reference: https://hackage.haskell.org/package/happy}
    source:
      Ext: [.y]
      Fl: lex|xpld
      Require: [import|%monad]
  Literate Happy:
    description: |-
      Literate Happy is a syntax variant that supports embedding
      code in its documentation by ignoring all program lines
      not led with a ">".
    links: {Reference: https://www.haskell.org/onlinereport/literate.html}
    source:
      Ext: [.ly]
      Require: [^>]
      Fl: lit
  LilyPond:
    description: |-
      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.
    links: {Website: https://lilypond.org/}
    source:
      Ext: [.ly]
      Bc: [['%{', '%}'], ['%', "\n"]]
      Fl: xdsl
  Yacc:
    description: |-
      Yacc (Yet Another Compiler Compiler) is a parser generator created at
      Bell Labs by Stephen C. Johnson for constructing deterministic
      bottom-up parsers from context-free grammars. A specification defines
      tokens, precedence rules, and grammar productions paired with semantic
      actions written in C. The tool translates the grammar into source code
      implementing an LALR(1) parser that reads tokens supplied by a lexical
      analyzer such as Lex. Yacc became a standard component of Unix
      toolchains and strongly influenced later parser generators and
      compiler construction practice. Modern implementations and compatible
      derivatives such as Bison are widely used in language tooling and
      software that requires efficient grammar-driven parsing.
    links: {Introduction: https://www.gnu.org/software/bison/, Reference: https://pubs.opengroup.org/onlinepubs/7908799/xcu/yacc.html}
    source:
      Ext: [.y]
      Like: C-like
      St: ;
      Fl: xcpp|xpld
  ASP.NET:
    description: |-
      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.

      Not to be confused with the earlier and now obsolete ASP, which
      ASP.NET superseded.
    links: {Website: https://learn.microsoft.com/aspnet/}
    source:
      Ext: [.aspx, .ascx, .master, .ashx, .asmx]
      Bc: [[<%--, --%>]]
      Co: ['for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xtpl
      Require: ['<%@|<%|<asp:']
      Forbid: ['<cf|<jsp|\{\{']
  Sather:
    description: |-
      Sather is an object-oriented programming language influenced by
      Eiffel and designed for strong typing and high performance.
    links: {Reference: https://www.cs.ucsb.edu/~cappello/sather/}
    source:
      Ext: [.sa]
      St: ;
      Str: [['"', '"']]
      Fl: xdead
      Require: [class]
      Bc: [[--, "\n"]]
  NIL:
    description: |-
      NIL (New Implementation of Lisp) was a Lisp dialect developed at MIT
      in the 1970s as a successor to MacLisp.
    links: {Reference: https://www.lispworks.com/documentation/HyperSpec/}
    source:
      Ext: [.nl]
      Like: Lisp-like
      Require: [\(DEFUN, \(defun]
      Fl: xdead
  AlgolW:
    description: |-
      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.
    links: {Reference: https://en.wikipedia.org/wiki/ALGOL_W}
    source:
      Ext: [.w]
      St: ;
      Sb: begin
      Eb: end
      Fl: xdead|xssep
      Require: [\bbegin\b|\bend\b|\bprocedure\b|\brecord\b]
      Forbid: [\bclass\b|\bdef\b|\bfn\b]
      Bc: [[comment, "\n"]]
  Hope:
    description: |-
      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
    links: {Reference: https://en.wikipedia.org/wiki/Hope_(programming_language)}
    source:
      Ext: [.hope]
      Bc: [[(*, '*)']]
      Fl: xdead
      Require: [\btype\b|\bdata\b|<=\b|\bcase\b]
      Forbid: [\bclass\b|\bdef\b|\bfn\b]
  SASL:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/SASL_(programming_language)}
    source:
      Ext: [.sasl]
      Fl: xdead
      Require: [\bwhere\b|\bif\b|\bthen\b|\belse\b|=]
      Forbid: [\bclass\b|\bdef\b|\bfn\b|\bbegin\b]
      Bc: [['||', "\n"]]
  SequenceL:
    description: |-
      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.
    links: {Introduction: https://en.wikipedia.org/wiki/SequenceL}
    source:
      Ext: [.sl, .seq]
      Str: [['"', '"', bse]]
      Fl: xdsl
      Require: ['\breduce\(|\bmap\(|\[|\]']
      Forbid: [\bclass\b|\bdef\b|\bfn\b]
      Bc: [['#', "\n"]]
  SELinuxPolicy:
    aka: ['SELinux policy', 'Security-Enhanced Linux policy', 'SELinux CIL']
    description: |-
      SELinux policy files define mandatory access-control rules for the
      SELinux security module. Reference Policy modules are commonly split
      into type-enforcement, interface, and file-context files, while CIL
      files describe compiled or intermediate policy forms. These files
      declare types, attributes, roles, users, constraints, transitions,
      file labels, and allow or audit rules used by policy compilers and
      module builders.
    links: {Reference Policy: https://github.com/SELinuxProject/refpolicy, CIL Reference: https://android.googlesource.com/platform/external/selinux/+/master/secilc/docs/cil_reference_guide.md, Module Tool: https://manpages.debian.org/trixie/selinux-policy-dev/policygentool.1.en.html}
    base:
      Str: [['"', '"', bse]]
      Fl: xcfg
    variants:
      source policy:
        Ext: [.te, .if, .fc]
        Bc: [['#', "\n"]]
        Require: ['^\s*(?:policy_module|interface|template|gen_require|optional_policy|tunable_policy)\s*\(|^\s*(?:type|attribute|typeattribute|role|allow|dontaudit|auditallow|neverallow|type_transition|role_transition|range_transition|genfscon|sid|class|common|sensitivity|category)\b|^\s*/.*(?:gen_context\(|[A-Za-z0-9_]+_u:[A-Za-z0-9_]+_r:[A-Za-z0-9_]+_t)']
      CIL policy:
        Ext: [.cil]
        Bc: [[';', "\n"]]
        Require: ['^\s*\((?:block|blockinherit|class|classorder|sid|sidcontext|user|role|type|typeattribute|typeattributeset|roletype|allow|dontaudit|auditallow|neverallow|typetransition|typechange|filecon|genfscon|boolean|tunable)\b']
  CIL:
    aka: [Common Intermediate Language]
    description: |-
      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.
    links: {Reference: https://learn.microsoft.com/dotnet/standard/managed-execution-process}
    source:
      Ext: [.cil]
      Like: C-like
      St: ;
      Str: [['"', '"']]
      Bc: [[;, "\n"], ['*', "\n"], [//, "\n"], ['#', "\n"]]
      Fl: xirf
  Unicon:
    description: |-
      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.
    links: {Website: http://www.unicon.org/}
    source:
      Ext: [.uni]
      Str: [['"', '"', bse]]
      Require: [\bprocedure\b|\bwrite\(|\bevery\b|\bclass\b]
      Forbid: [\bdef\b|\bfn\b|\bmodule\b]
      Bc: [['#', "\n"]]
  XPL0:
    description: |-
      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.
    links: {Website: http://www.xpl0.org/}
    source:
      Ext: [.xpl, .xpl0]
      Bc: [[/*, '*/']]
      St: ;
      Fl: xdead
      Require: [DECLARE|CALL|BEGIN|END]
      Forbid: [class|def|fn]
  Motorola SREC:
    description: |-
      Motorola SREC is a text-based file format for encoding binary data
      in hexadecimal form, commonly used for programming microcontrollers
      and embedded systems. Data is stored as a sequence of "S-records"
      beginning with an S character followed by a type identifier, address,
      data bytes, and a checksum. The format supports multiple address sizes
      through different record types and is widely used in firmware
      distribution and device programming tools.

      Sometimes the format is called SRECORD or "S-Record", though
      technically the latter refers to the format of an individual line.
    links: {Introduction: https://en.wikipedia.org/wiki/Motorola_S-record}
    source:
      Ext: [.srec, .s19, .s28, .s37]
      Fl: xser
      Require: [S0|S1|S2|S3|S7|S8|S9]
  Zimpl:
    description: |-
      Zimpl is an algebraic modeling language for translating mathematical
      optimization models into solver-readable linear or mixed-integer
      programs. Zimpl model files declare sets, parameters, variables,
      objectives, constraints, functions, checks, and data initialization
      rules for mathematical programming workflows.
    links: {Website: https://zimpl.zib.de/, Reference: https://zimpl.zib.de/zimpl.pdf, Repository: https://github.com/scipopt/zimpl}
    source:
      Ext: [.zpl]
      Bc: [['#', "\n"]]
      Str: [['"', '"']]
      St: ;
      Require: ['^\s*(?:include\s+"|(?:set|param|var|minimize|maximize|subto|do)\b|def(?:numb|strg|bool|set)\b)|\b(?:forall|sum|prod)\s*<[^>]+>\s+in\b']
      Co: ['if ', 'then ', 'else ', 'end ', 'forall ', 'sum ', 'prod ', 'with ', 'in ', 'do ', 'and ', 'or ', 'xor ', 'not ', '!= ', '== ', '<= ', '>= ']
      Fl: xmat
  DNS Zone:
    aka: ['DNS zone file', zonefile, 'DNS master file']
    description: |-
      DNS zone files are text master files used by name servers to load DNS
      zones. They contain control entries and resource records that map
      names to addresses, mail exchangers, aliases, services, and other DNS
      data used by the domain name system.
    links: {Reference: https://www.rfc-editor.org/rfc/rfc1035#section-5}
    source:
      Ext: [.zone, .arpa]
      Files: [db.0, db.127, db.255, db.empty, db.local, db.root, named.root, root.zone]
      Bc: [[';', "\n"]]
      Str: [['"', '"', bse]]
      Require: ['^\s*(?:\$ORIGIN|\$TTL|\$INCLUDE|\$GENERATE)\b|^\s*(?:@|[A-Za-z0-9_*.@-][A-Za-z0-9_*.@-]*)?\s+(?:\d+\s+)?(?:IN\s+)?SOA\s']
      Fl: xcfg
  Perl-like:
    source:
      St: ;
      Fl: end|heredoc
      Lrb: ^=[A-Za-z]
      Lre: ^=cut
      Bc: [['#', "\n"]]
  Perl:
    description: |-
      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.
    links: {Website: https://perldoc.perl.org/}
    source:
      Ext: [.pl, .pm, .ph]
      She: [perl, perl5]
      Like: Perl-like
      Forbid: [use v6;]
      Co: ['for ', for(, 'foreach ', foreach(, 'if ', if(, 'elsif ', elsif(, 'while ', while(, 'until ', until(, 'unless ', unless(, 'given ', given(, 'when ', when(, 'catch ', catch(, 'eq ', 'ne ', 'else ', 'and ', 'or ', '|| ', '&& ', '!= ', '== ']
  Raku:
    description: |-
      Raku is a multi-paradigm language (formerly Perl 6) with rich grammar
      and regex support.
    links: {Reference: https://docs.raku.org/language/syntax}
    source:
      Ext: [.pl, .pm, .ph]
      She: [raku]
      Like: Perl-like
      Require: [use v6;]
      Co: ['== ', '≡ ', '!= ', '≠ ', '!== ', '≢ ', '< ', '⊂ ', '!< ', '⊄ ', '<= ', '≤ ', '⊆ ', '!<= ', '⊈ ', '> ', '⊃ ', '!> ', '⊅ ', '>= ', '≥ ', '⊇ ', '!>= ', '⊉ ', '=~= ', '≅ ', '=== ', 'eq ', '!eq ', 'eqv ', 'ne ', 'gt ', 'ge ', 'lt ', 'le ', =:=, 'CATCH ', 'CONTROL ', 'DOC ', 'NEXT ', 'and ', 'default ', 'do {', 'else ', 'elsif ', 'emit ', 'for ', 'gather ', 'given ', 'if ', 'last ', loop (, 'next ', 'once ', 'or ', 'orwith ', 'react {', 'redo ', 'repeat ', 'start {', 'supply ', 'unless ', 'until ', 'when ', 'whenever ', 'while ', 'with ', 'without ']
  OWL:
    aka: ['Web Ontology Language', 'OWL 2']
    description: |-
      OWL is the W3C Web Ontology Language, used to define Semantic Web
      ontology documents with classes, properties, individuals, data values,
      axioms, profiles, and formally defined meaning. OWL documents are
      primarily exchanged as RDF, but OWL 2 also defines XML, functional,
      and Manchester concrete syntaxes.
    links: {Website: https://www.w3.org/OWL/, Overview: https://www.w3.org/TR/owl2-overview/, Functional Syntax: https://www.w3.org/TR/owl2-syntax/, XML Serialization: https://www.w3.org/TR/owl2-xml-serialization/, Manchester Syntax: https://www.w3.org/TR/owl2-manchester-syntax/}
    base:
      Fl: xmdl
    variants:
      RDF/XML:
        Ext: [.owl]
        Like: XML-like
        Require: ['(?:xmlns:owl=|<owl:Ontology\b|http://www\.w3\.org/2002/07/owl#)']
      OWL/XML:
        Ext: [.owx]
        Like: XML-like
      functional syntax:
        Ext: [.ofn]
        Bc: [['#', "\n"]]
        Str: [['"', '"', ml|bse], ['<', '>']]
        Require: ['^\s*(?:Prefix|Ontology)\(']
      Manchester syntax:
        Ext: [.omn]
        Str: [['"', '"', bse], ['<', '>']]
        Require: ['^\s*(?:Prefix:|Ontology:|Class:|ObjectProperty:|DataProperty:|Individual:)']
