  8th:
    description: |-
      Eighth is a stack-oriented concatenative language in the Forth family.
      It combines terse postfix composition with batteries-included runtime
      facilities and scripting-oriented tooling.
    links: {Ewderence: https://8th-dev.com/manual.html}
    source:
      Fl: xprop
  AHDL:
    aka: ['Altera Hardware Description Language']
    description: |-
      AHDL is Intel/Altera's proprietary hardware description and design-entry
      language for Quartus and MAX+PLUS FPGA/CPLD projects. It uses Text
      Design Files to describe synthesizable digital logic with subdesigns,
      ports, constants, parameters, Boolean equations, truth tables, state
      machines, and user-defined or vendor-supplied functions.
    links: {Reference: https://www.intel.com/content/www/us/en/docs/programmable/683283/18-1/ahdl-support.html}
    source:
      Ext: [.tdf]
      Bc: [['%', '%'], [--, "\n"]]
      Str: [['"', '"']]
      St: ;
      Fl: xhdl|xprop
      Co: ['IF ', 'THEN ', 'ELSE ', 'ELSIF ', 'CASE ', 'FOR ', 'GENERATE ', 'SUBDESIGN ', 'VARIABLE ', 'BEGIN ', 'END ', 'AND ', 'OR ', 'NAND ', 'NOR ', 'XOR ', 'XNOR ', '== ', '!= ', '<= ', '>= ']
  Alchemist:
    description: |-
      Alchemist is a non-deterministic esoteric programming language based on
      chemical reaction networks.  Programs are multisets of rewrite rules
      over atoms, and execution repeatedly chooses an applicable rule at
      random until no rule remains applicable.  The language has special
      right-hand-side atoms for input and output, supports numeric
      multiplicities on atoms, and uses zero-multiplicity tests as a control
      mechanism.  In practice it is implemented as a small interpreted
      language rather than a notation embedded in another host language.
    links: {Reference: https://esolangs.org/wiki/Alchemist, Repository: https://github.com/bforte/Alchemist}
    source:
      Ext: [.crn]
      Bc: [['#', "\n"]]
      Str: [['"', '"']]
      Co: ['+', '->', '!']
  Alore:
    description: |-
      Alore was a small object-oriented scripting language with Python-like
      syntax and semantics. It was designed as an experimental language and
      implementation project rather than a widely deployed production
      platform. There has been no activity in the repository since 2011.

      Repository:: https://github.com/JukkaL/alore
    source:
      Ext: [.alo]
      Like: 'Python-like'
      Fl: xdead
  AMPL:
    aka: ['A Mathematical Programming Language']
    description: |-
      AMPL is a proprietary algebraic modeling language for mathematical
      programming and optimization. Models describe sets, parameters,
      variables, objectives, constraints, and solver commands in a notation
      close to mathematical programming formulations, with data and command
      scripts commonly split into separate files.
    links: {Website: https://ampl.com/, Reference: https://dev.ampl.com/ampl/books/ampl/examples/index.html}
    source:
      Ext: [.mod, .dat, .run]
      Bc: [['/*', '*/'], ['#', "\n"]]
      Str: [['"', '"'], ["'", "'"]]
      St: ;
      Require: ['\b(?:var|param|set|subject\s+to|minimize|maximize|solve|model|data|display)\b']
      Co: ['if ', 'then ', 'else ', 'while ', 'repeat ', 'until ', 'for ', 'forall ', 'exists ', 'sum ', 'prod ', 'and ', 'or ', 'not ', '== ', '!= ', '<> ', '<= ', '>= ']
      Fl: xmat|xprop
  ANSYS Parametric Design Language:
    description: |-
      ANSYS Parametric Design Language is a scripting language used in the
      ANSYS engineering simulation environment to automate modeling,
      analysis, and postprocessing tasks. It allows users to describe finite
      element models, define parameters, control solution procedures, and
      extract results through command scripts executed by the ANSYS
      solver. The language is widely used in engineering workflows to
      automate simulation studies and build parametric models.
    links: {Website: https://www.ansys.com/}
    source:
      Ext: [.apdl]
      Require: ['/PREP7', '/SOLU', '/POST1', '*DO', '*ENDDO']
      St: '!'
      Fl: xprop
  Apex:
    aka: ["Apex Class"]
    description: |-
      Apex is the proprietary server-side programming language of the Salesforce
      platform.  It is used to implement business logic that runs inside the
      Salesforce application environment and is tightly integrated with the
      platform’s data model, security system, and transaction framework.
    links: {Reference: https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/}
    source:
      Like: 'Java'
      Ext: [.cls, .trigger]
      Bc: [['/*', '*/'], ['//', "\n"]]
      Str: [['"', '"']]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'switch(', 'while ', 'while(', 'else ', 'else{', 'try ', 'try{', 'catch ', 'catch(', 'finally ', 'finally{', '|| ', '&& ', '!= ', '== ']
      Fl: xprop
  Astro (WIP):
    description: |-
      Astro is an in-progress statically typed systems language aimed at
      combining rapid prototyping with high-performance, memory-safe
      programming.  Its design emphasizes full type inference, structural
      typing, data-race-free concurrency, and compile-time lifetime analysis
      instead of a tracing garbage collector.  The current implementation is
      written in Rust and the project is still explicitly described by its
      author as not yet ready for practical use.
    links: {Reference: https://github.com/astrolang/astro}
    source:
      Like: 'C-like'
      Ext: [.astro]
      Str: [['"', '"', 'ml', 'bse'], ['''', '''', 'ml', 'bse']]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ', '.map']
  AutoIt:
    description: |-
      AutoIt is a scripting language for automating the Windows GUI and
      general scripting tasks.  It uses a BASIC-like syntax with variables
      prefixed by `$`, line comments beginning with `;`, and block comments
      delimited by `#cs`/`#ce` or `#comments-start`/`#comments-end`.
    links: {Website: https://www.autoitscript.com/}
    source:
      Ext: [.au3]
      Str: [['"', '"', bse], ["'", "'", bse]]
      Bc: [['#cs', '#ce', sol], ['#comments-start', '#comments-end', sol], [;, "\n"]]
      Fl: xprop
      Co: ['for ', for(, 'if ', if(, 'while ', while(, 'else ', '&& ', '|| ', '!= ', '== ']
  BASIC-256:
    description: |-
      BASIC-256 was a simplified BASIC dialect created for teaching children
      introductory programming concepts. It emphasizes an approachable
      educational environment over language complexity or industrial use.
      Last updated in 2020.
    links: {Reference: https://basic256.org/, Repository: https://sourceforge.net/projects/basic256prtbl/}
    source:
      Ext: [.bas]
      Like: 'BASIC-like'
      Fl: xdead
  Bitbucket Pipeline:
    description: |-
      Bitbucket Pipeline is a proprietary continuous integration and delivery
      configuration format used by Bitbucket Cloud to define automated
      build, test, and deployment workflows. It describes pipelines as
      sequences of steps executed in containerized environments, enabling
      repository-driven automation tied to version control events.
    links: {Reference: https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/}
    source:
      Like: 'YAML-like'
      Ext: [.yml, .yaml]
      Require: ['^\s*pipelines\s*:', '\bstep\s*:', '\bscript\s*:']
      Fl: xprop
  BizTalk Orchestration:
    description: |-
      BizTalk Orchestration is a proprietary workflow definition format used
      to model executable business processes within Microsoft BizTalk
      Server. It represents message flows, service interactions, and process
      logic in a form that can be compiled and executed by the orchestration
      engine.
    links: {Reference: https://learn.microsoft.com/en-us/biztalk/core/orchestrations, Repository: https://github.com/MicrosoftDocs/biztalk-docs}
    source:
      Ext: [.odx]
      Require: ['<\s*(?:om:)?Module\b', '<\s*(?:om:)?Service\b', '<\s*(?:om:)?Port\b']
      Str: [['"', '"', 'ml'], ['''', '''', 'ml']]
      Fl: xprop
  BizTalk Pipeline:
    description: |-
      BizTalk Pipeline is the pipeline configuration and component-binding
      format used by Microsoft BizTalk Server to define receive and send
      processing stages for integration workflows.
    links: {Reference: https://learn.microsoft.com/en-us/biztalk/core/pipelines}
    source:
      Like: 'XML-like'
      Ext: [.btp]
      Fl: xprop
  Brainfuck:
    description: |-
      Brainfuck is a minimal esoteric programming language built from eight
      single-character commands operating on a byte tape and data pointer.
      It is primarily used as a thought experiment and implementation toy.
    links: {Introduction: https://en.wikipedia.org/wiki/Brainfuck}
    source:
      Ext: [.b, .bf]
  BrightScript:
    description: |-
      BrightScript is a proprietary scripting language used for developing applications
      on Roku streaming devices. Programs define application logic, user
      interface behavior, and media playback control for Roku channels and
      other platform software. The language is integrated with Roku’s
      component system and runtime libraries, allowing scripts to create
      interface components, respond to events from the device environment,
      and control video and audio streaming. BrightScript code runs within
      the Roku operating environment and interacts with platform APIs for
      networking, graphics, and media playback.

      BrighterScript is an open-source implementation of BrightScript.
    links: {Reference: https://developer.roku.com/docs/references/brightscript/language/brightscript-language-reference.md, Repository: https://github.com/rokudev/brighterscript}
    source:
      Like: 'BASIC-like'
      Ext: [.brs]
      Str: [['"', '"', bse]]
  C# Designer:
    description: |-
      C# Designer files are auto-generated source files produced by
      development tools such as Visual Studio to support visual designers
      for user interfaces and components. They contain partial class
      definitions that initialize and configure controls, and are
      regenerated by the tooling rather than edited directly by developers.
    links: {Reference: https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/design-time}
    source:
      Like: 'C#'
      Ext: [.Designer.cs]
      Require: ['partial\s+class\s+\w+', 'InitializeComponent\s*\(']
  CCScript:
    aka: [CCS]
    description: |-
      CCScript is a small scripting language used for EarthBound SNES
      ROM hacking.  It is rejected as a narrow single-game ROM-hacking
      DSL rather than a broadly used production language.
    links: {Reference: http://starmen.net/pkhack/ccscript/CCScript.html}
    source:
      Ext: [.ccs]
      Like: C-like
      Str: [['"', '"']]
      Co: ['if ', 'menu ', 'command ', 'define ', 'ROM[', 'ROMTBL[']
  Cocoa:
    description: |-
      Cocoa is the prprietary native application framework for MacOS,
      providing APIs for user interface construction, event handling, and
      system integration. It is typically used with Objective-C or
      Objective-C++ source files to build desktop applications targeting the
      Apple platform, and forms the core of macOS application development.
    links: {Reference: https://developer.apple.com/documentation/Cocoa}
    source:
      Like: 'Objective-C'
      Ext: [.m, .mm]
      Require: ['#import\s*<Cocoa/Cocoa\.h>', '@interface', '@implementation']
      Fl: xprop
  DenizenScript:
    description: |-
      DenizenScript is a scripting language used by the Denizen plugin for
      Minecraft servers to define interactive behaviors, events, and
      automation. It provides a structured, YAML-like syntax for describing
      scripts that respond to in-game events, control entities, and manage
      server-side logic.
    links: {Website: https://guide.denizenscript.com/, Repository: https://github.com/DenizenScript/Denizen}
    source:
      Like: 'YAML-like'
      Ext: [.dsc]
      Require: ['^\s*\w+:', '^\s*-\s+\w+', '\b(?:type|script)\s*:']
      Str: [['"', '"', 'ml', 'bse'], ['''', '''', 'ml']]
  DOORS DXL:
    description: |-
      DOORS DXL is the scripting and extension language of IBM Rational
      DOORS. It is used to automate requirements-management workflows,
      manipulate database objects, and build custom tool behavior.
    links: {Reference: https://www.ibm.com/docs/kk/SSYQBZ_9.7.2/com.ibm.doors.configuring.doc/topics/c_dxl.html}
    source:
      Like: 'C-like'
      Ext: [.dxl]
      Fl: xprop
  EmiT:
    aka: [emiT]
    description: |-
      EmiT is a time-travel themed esoteric programming language whose
      programs manipulate variables across parallel timelines. Its own
      repository describes it as a small hobby project, and the project links
      to the Esolang wiki.
    links: {Reference: https://esolangs.org/wiki/EmiT, Repository: https://github.com/nimrag-b/emiT-C}
    source:
      Ext: [.emit]
      Bc: [['//', "\n"]]
      Str: [['"', '"']]
      Co: ['create ', 'kills ', 'warps ', 'time ', 'dead ', 'alive ', 'exists ']
  Emojicode:
    description: |-
      Emojicode is an esoteric programming language that uses emoji heavily
      in its syntax. It is designed more as a novelty language experiment
      than as a conventional production language.
    links: {Website: https://www.emojicode.org/}
    source:
      Ext: [.emojic]
      Fl: xdead
  FEN:
    description: |-
      FEN usually refers to Forsyth-Edwards Notation, a chess-position
      serialization format rather than a general-purpose programming
      language.
    source:
      Ext: [.fen]
      Fl: xser
  Focus:
    description: |-
      Focus is the proprietary procedural and reporting language used by
      Information Builders FOCUS and later WebFOCUS products. A FOCEXEC is a
      stored procedure that can combine Dialogue Manager control statements
      with reporting, SQL, and data-maintenance syntax, and vendor
      documentation describes these procedures as executable server-side
      files.
    links: {Reference: https://webfocusinfocenter.informationbuilders.com/wfappent/TL3s/TL_server/source/h2_Proc_Runtime_Process_Essentials.htm}
    source:
      Ext: [.focexec]
      Bc: [['-*', "\n"]]
      Require: ['^\s*-', '\b(?:TABLE|GRAPH|MATCH|MODIFY|DEFINE|JOIN|FILEDEF|SQL)\b']
      Fl: xprop
  ForgeConfig:
    description: |-
      ForgeConfig refers to Minecraft Forge configuration files and related
      modding-specific data formats. It is a narrow ecosystem format rather
      than an independent general-purpose language.
    source:
      Ext: [.cfg, .toml]
      Fl: xcfg|xprop
  GAMS:
    aka: ['General Algebraic Modeling System']
    description: |-
      GAMS is a proprietary algebraic modeling language and system for
      mathematical programming and optimization. GAMS model files describe
      sets, parameters, variables, equations, models, solve statements, and
      display commands in a compact notation intended to pass mathematical
      programs to solver backends.
    links: {Website: https://www.gams.com/products/gams/gams-language/, Quickstart: https://www.gams.com/latest/docs/UG_TutorialQuickstart.html, Comments: https://www.gams.com/latest/docs/UG_GAMSPrograms.html}
    source:
      Ext: [.gms]
      Bc: [['$ontext', '$offtext', sol], ['*', "\n", sol], ['!!', "\n"]]
      Str: [['"', '"'], ["'", "'"]]
      St: ;
      Require: ['\b(?:sets?|parameters?|variables?|equations?|models?|solve|display)\b']
      Co: ['if ', 'elseif ', 'else ', 'loop ', 'while ', 'for ', 'sum(', 'prod(', 'and ', 'or ', 'not ', 'yes ', 'no ', '=e=', '=l=', '=g=', '=n=']
      Fl: xmat|xprop
  Headache:
    description: |-
      Headache is an esolang that compiles to 8 Bit Brainfuck
    links: {Repository: https://github.com/LucasMW/Headache}
    source:
      Ext: [.bf]
  Hex0:
    description: |-
      Hex0 is an extremely small bootstrap-oriented language or encoding
      format used in minimalist self-hosting and bootstrapping experiments.
    links: {Repository: https://github.com/ironmeld/builder-hex0}
    source:
      Ext: [.hex0]
  Hex1:
    description: |-
      Hex1 is a follow-on bootstrap language in the Hex series, intended for
      extremely small and auditable program construction in staged
      bootstrapping environments.
    source:
      Ext: [.hex1]
  Hex2:
    description: |-
      Hex2 is another member of the tiny Hex bootstrap-language family used
      in software bootstrapping experiments that minimize trusted binary
      seeds.
    source:
      Ext: [.hex2]
  HiCAD:
    description: |-
      HiCAD is associated with a proprietary CAD system and its automation or
      customization formats, making it a narrow vendor-specific language
      label rather than a broadly adopted general language.
    source:
      Ext: [.szn, .sza, .szx]
      Fl: xprop
  HiCAD Script:
    description: |-
      HiCAD Script is a proprietary scripting language used within the HiCAD
      CAD system developed by ISD Software und Systeme for automating design
      tasks and parametric modeling workflows. It enables users to define
      procedures, parameters, and operations that control geometry creation
      and modification within the CAD environment. The language is primarily
      used in industrial design and engineering contexts to streamline
      repetitive modeling processes and enforce design rules.

      HiCAD source format is not well documented. Some versions may interpret
      ";" as a winged-comment leader.
    links: {Website: https://www.isdgroup.com/, Introductiuon: https://www.hicad-help.com/}
    source:
      Ext: [.hicad, .hcs]
      Bc: [['//', "\n"]]
      Require: ['BEGIN', 'END', 'CALL ', 'PARAMETER', 'PROCEDURE']
      Fl: xprop
  HolyC:
    description: |-
      HolyC is the systems programming language used by TempleOS. It is
      essentially a C-family dialect tightly bound to that operating system
      and its tooling model.
    links: {Website: https://holyc-lang.com/}
    source:
      Like: 'C-like'
      Ext: [.HC]
      Fl: xdead
  Igor Pro:
    description: |-
      Igor Pro is the procedural and formula language used inside the Igor
      Pro scientific data-analysis environment. It supports numerical
      analysis, graphing, and laboratory automation tasks.
    links: {Website: https://www.wavemetrics.com/}
    source:
      Ext: [.ipf]
      Fl: xmat|xprop
  RSI IDL:
    aka: ['Interactive Data Language', 'NV5 IDL', 'Harris IDL']
    description: |-
      RSI IDL is the proprietary array-oriented programming language now
      maintained by NV5 Geospatial Software and historically associated with
      Research Systems, Inc. It is used for scientific data analysis,
      visualization, image processing, and remote-sensing workflows. IDL
      programs are normally stored as .pro files containing procedures,
      functions, main-level programs, or include files; the language is
      interactive and is commonly used in astronomy, geoscience, and other
      numerical research environments. The implementation and ecosystem are
      proprietary, though compatible open-source implementations such as GDL
      exist.
    links: {Website: https://www.nv5geospatialsoftware.com/Products/IDL, Reference: https://www.nv5geospatialsoftware.com/docs/Overview_of_IDL_Program.html}
    source:
      Ext: [.pro]
      Bc: [[;, "\n"]]
      Str: [['"', '"'], ["'", "'"]]
      Require: ['^\s*(?:pro|function)\s+\w+', '\b(?:begin|endif|endfor|endforeach|endwhile|endrep)\b', '\b(?:plot|print|read|write|where|findgen|fltarr)\b']
      Co: ['if ', 'then ', 'else ', 'for ', 'foreach ', 'while ', 'repeat ', 'case ', 'switch ', 'and ', 'or ', 'not ', 'eq ', 'ne ', 'lt ', 'le ', 'gt ', 'ge ', 'IF ', 'THEN ', 'ELSE ', 'FOR ', 'WHILE ', 'CASE ', 'SWITCH ']
      Fl: xmat|xprop
  InstallShield:
    description: |-
      A scripting language used within the InstallShield system to define
      installer logic, control installation flow, and interact with the
      target environment during software deployment. It is designed
      specifically for authoring Windows installation packages and
      integrates closely with the InstallShield toolchain.
    links: {Website: https://www.revenera.com/install/products/installshield, Reference: https://docs.revenera.com/installshield/helplibrary/InstallScript.htm}
    source:
      Like: 'C'
      Ext: [.rul]
      Fl: xprop
  Informix 4GL:
    description: |-
      Informix 4GL is a fourth-generation language for building database
      applications on Informix systems. It combines database access, forms,
      reporting, and business logic in an integrated environment.
    links: {Introduction: https://en.wikipedia.org/wiki/Informix-4GL}
    source:
      Ext: [.4gl]
      Fl: xprop|xdead
  Juniper Junos:
    description: |-
      Juniper Junos is the hierarchical configuration language used by
      Juniper Networks routers, switches, and firewalls.  Configurations are
      organized as nested blocks introduced by keywords and braces, with
      statements terminated by semicolons.  The format is primarily used to
      describe device interfaces, routing policy, protocols, and other
      operating parameters.
    links: {Reference: https://www.juniper.net/documentation/}
    source:
      Ext: [.conf]
      Like: C-like
      Str: [['"', '"', bse]]
      Bc: [['/*', '*/'], ['#', "\n"]]
      St: ;
      Fl: xcfg|xprop
      Require: ['^\s*(?:system|interfaces|protocols|policy-options|routing-options|firewall|snmp|chassis)\s*\{', '^\s*[A-Za-z0-9_-]+\s+\{', ';\s*(?:#.*)?$']
  Koka:
    description: |-
      Koka is a research-oriented functional programming language with a type
      and effect system that makes side effects explicit in function types.
    links: {Reference: https://github.com/koka-lang/koka}
    source:
      Ext: [.kk]
  LOLCODE:
    description: |-
      LOLCODE is an esoteric language inspired by internet meme vernacular.
      Its syntax intentionally imitates playful caption text rather than
      conventional programming notation.
    links: {Website: https://lolcode.org/, Repository: https://github.com/justinmeza/lolcode}
    source:
      Ext: [.lol]
  LSL:
    aka: ['Linden Scripting Language']
    description: |-
      LSL is the Linden Scripting Language used to attach scripted behavior
      to objects in the Second Life virtual world. Scripts run on Second Life
      servers and define state blocks, event handlers, variables, functions,
      and calls to built-in ll* functions that react to touches, timers,
      chat, object movement, inventory changes, and other virtual-world
      events. It belongs in chaff because it is tightly bound to Linden Lab's
      proprietary Second Life platform and runtime.
    links: {Reference: https://create.secondlife.com/script/lsl-reference/, Tutorial: https://wiki.secondlife.com/wiki/Getting_started_with_LSL}
    source:
      Ext: [.lsl]
      Like: 'C-like'
      St: ;
      Str: [['"', '"', bse]]
      Co: ['state ', 'default', 'state_entry', 'touch_start', 'listen', 'timer', 'link_message', 'collision_start', 'sensor', 'control', 'if ', 'if(', 'else ', 'for ', 'for(', 'while ', 'while(', 'do ', 'jump ', '&& ', '|| ', '!= ', '== ']
      Fl: xprop
  Luna:
    description: |-
      Luna is a functional programming language with both textual and visual
      forms, aimed at interactive development and data-oriented
      workflows. The public repository describes it as a visual and textual
      functional programming language and shows source files using the .luna
      extension. Development of this language ceased in 2016 and its website
      has vanished.
    links: {Repository: https://github.com/binary132/luna}
    source:
      Ext: [.luna]
      Bc: [['#', "\n"]]
      Str: [['"', '"']]
  Magik:
    description: |-
      A dynamically typed, object-oriented language used within the GE
      Smallworld platform for building and customizing geospatial and asset
      management applications. It emphasizes interactive development and
      tight integration with the underlying system’s data and runtime
      environment.
    links: {Website: https://www.ge.com/digital/applications/smallworld-gis}
    source:
      Like: 'Smalltalk'
      Ext: [.magik]
      Fl: xprop
  Max:
    description: |-
      A patch-based programming environment used for interactive audio,
      visual, and multimedia system development, where programs are
      constructed by connecting functional objects into signal-processing
      graphs.
    links: {Website: https://cycling74.com/products/max}
    source:
      Like: 'JSON-like'
      Ext: [.max]
      Fl: xcfg|xprop
  Metal Shading Language:
    aka: ["Metal", "MSL"]
    description: |-
      A GPU programming language used within Apple’s Metal framework to
      implement graphics and compute shaders for rendering and parallel
      processing on Apple platforms. It is designed for high-performance
      execution and close integration with the system’s graphics and compute
      APIs.
    links: {Website: https://developer.apple.com/metal/, Specification: https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf}
    source:
      Like: 'C-like'
      Ext: [.metal]
      Fl: xshd|xprop
  Mlatu:
    description: |-
      A declarative concatenative programming language. It uses term rewriting as an evalutation model.
    links: {Repository: https://github.com/mlatu-lang/mlatu}
    source:
      Ext: [.mlt, .mlb]
  Monkey C:
    description: |-
      Monkey C is the application language used for developing apps for
      Garmin devices through the Connect IQ platform.
    links: {Website: https://developer.garmin.com/connect-iq/, Reference: https://developer.garmin.com/connect-iq/reference-guides/monkey-c-reference/, Repository: https://github.com/garmin/connectiq-sdk}
    source:
      Like: 'C-like'
      Ext: [.mc]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
  MQL4:
    description: |-
      A domain-specific language used in the MetaTrader 4 platform for
      developing automated trading strategies, custom indicators, and
      scripts that operate within financial markets.

      Website::
      https://docs.mql4.com/ +
    source:
      Like: 'C-like'
      Ext: [.mq4]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xprop
  MQL5:
    description: |-
      MQL5 is the proprietary trading-script and indicator language used by
      MetaTrader 5. It is designed for expert advisors, custom indicators,
      and automated trading strategies. It succeeded MQL4.
    links: {Website: https://www.mql5.com/en}
    source:
      Like: 'C-like'
      Ext: [.mq5, .mqh]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xprop
  Natural:
    description: |-
      Natural is a fourth-generation programming language developed by
      Software AG for building business applications, particularly in
      conjunction with the Adabas database system. It is widely used in
      enterprise environments, especially in Europe, for transaction
      processing, reporting, and database-driven applications. The language
      emphasizes high-level data access and structured programming
      constructs suited to business logic and batch processing.
    links: {Introduction: https://en.wikipedia.org/wiki/Natural_(programming_language), Website: https://documentation.softwareag.com/natural/}
    source:
      Ext: [.nsn, .nsp, .nsm]
      Require: ['DEFINE DATA', 'END-DEFINE', 'READ ', 'FIND ', 'WRITE ', 'END']
      Fl: xprop
  NASTRAN DMAP:
    description: |-
      NASTRAN DMAP is a dproprietary omain-specific language used within MSC Nastran to
      control and customize finite element analysis workflows by defining
      sequences of solution modules and data manipulations. It allows
      advanced users to alter solver behavior and construct specialized
      analysis procedures within the Nastran environment.
    links: {Reference: 'https://simcompanion.mscsoftware.com/infocenter/index?page=content&id=DOC10735'}
    source:
      Ext: [.dmap]
      Bc: [['$', "\n"]]
      Require: ['^\s*\$', '\b(?:BEGIN|END|ALTER|COMPILE|EXEC|DBSET|ASSIGN)\b']
      Fl: xprop|xdead
  Nu:
    description: |-
      Nu is a Lisp-like language for the Apple's proprietary
      Objective-C runtime and Cocoa environment. It is a niche
      language with little recent activity and a small ecosystem. No
      repository activity since 2033, no releases since 2019.
    links: {Introduction: https://en.wikipedia.org/wiki/Nu_(programming_language)}
    source:
      Ext: [.nu]
      Like: "Lisp-like"
      Fl: xdead
  NWScript:
    aka: [NSS]
    description: |-
      NWScript is the C-like scripting language developed by BioWare for
      Neverwinter Nights and related Aurora/Electron-engine games. Source
      files are plain-text .nss scripts compiled to .ncs bytecode and are
      used for module events, creature behavior, conversations, item use,
      triggers, placeables, cutscenes, and other game logic. It is tightly
      bound to the Neverwinter Nights family of game engines and toolsets.
    links: {Lexicon: https://nwnlexicon.com/, Comments: https://nwnlexicon.com/Comments, Vault: https://neverwintervault.org/project/nwn1/script/nsm-bytecode-assembler-nwscript}
    source:
      Ext: [.nss]
      Bc: [['/*', '*/'], ['//', "\n"]]
      Str: [['"', '"', bse]]
      St: ;
      Require: ['\b(?:void\s+main\s*\(|OBJECT_SELF|GetFirstPC|GetObjectByTag|AssignCommand|DelayCommand|Action[A-Za-z]*|CreateObject|ApplyEffectToObject|ExecuteScript|SpeakString|SetLocal[A-Za-z]*|GetLocal[A-Za-z]*|(?:object|effect|event|location|talent|vector)\s+[A-Za-z_])\b']
      Co: ['if ', if(, 'else ', 'for ', for(, 'while ', while(, 'do ', 'switch ', 'case ', 'return ', 'void ', 'int ', 'float ', 'string ', 'object ', 'effect ', 'location ', 'vector ', '&& ', '|| ', '!= ', '== ']
      Fl: xprop
  Oracle Forms:
    description: |-
      Oracle Forms is a development environment and runtime system for
      building database-driven applications on Oracle Database, with form
      definitions stored in binary modules. The files are created and
      maintained using Oracle Forms Builder and executed within the Oracle
      Forms runtime, rather than edited as text, and the technology is
      proprietary to Oracle.
    links: {Reference: https://docs.oracle.com/en/middleware/developer-tools/forms/}
    source:
      Ext: [.fmb, .mmb]
      Fl: xprop
  Oracle Reports:
    description: |-
      Oracle Reports is a report-definition environment used to design and
      generate formatted output from Oracle databases, with report
      specifications stored in binary module files. These files are created
      and managed using Oracle Reports Builder and executed by the Oracle
      Reports runtime, rather than edited directly as text, and the
      technology is proprietary to Oracle.
    links: {Reference: https://docs.oracle.com/en/middleware/reports/}
    source:
      Ext: [.rdf, .rex]
      Fl: xprop
  Patran Command Language:
    description: |-
      Patran Command Language is a propritary scripting language used within MSC Patran
      to automate modeling, preprocessing, and analysis tasks in finite
      element workflows. It provides a programmable interface for
      interacting with the modeling environment, enabling users to define
      procedures, manipulate data, and control execution of analysis-related
      operations.
    links: {Reference: 'https://simcompanion.mscsoftware.com/infocenter/index?page=content&id=DOC10744'}
    source:
      Ext: [.pcl]
      Bc: [['$', "\n"]]
      Require: ['^\s*\$\s*\w+', '^\s*(?:STRING|REAL|INTEGER)\s+\w+']
      Str: [['"', '"', 'ml']]
      Fl: xprop
  PGN:
    description: |-
      PGN is a text-based format for recording and exchanging chess games. A
      file contains one or more game records consisting of descriptive
      metadata followed by the sequence of moves played in the
      game. Metadata is expressed as tag pairs that identify information
      such as the players, event, date, and result, while the move text
      lists the moves in standard algebraic notation with optional comments
      and variations. The format is widely used by chess software,
      databases, and online services for storing, analyzing, and sharing
      game records.

      Introduction:
      https://en.wikipedia.org/wiki/Portable_Game_Notation
    links: {Reference: https://www.saremba.de/chessgml/standards/pgn/pgn-complete.htm}
    source:
      Ext: [.pgn]
      Bc: [['%', "\n"]]
      Fl: xcfg
  PL/S:
    description: |-
      PL/S is a systems programming language developed by IBM for internal
      use in implementing operating system components, most notably in
      MVS. It is syntactically related to PL/I but was designed for
      low-level programming tasks requiring close control over hardware and
      performance characteristics. The language was not publicly
      standardized and was primarily used within IBM for system software
      development. It was superseded by PL/X.
    links: {Introduction: https://en.wikipedia.org/wiki/PL/S}
    source:
      Like: 'PL/I-like'
      Ext: [.pls]
      Require: ['\b(?:PROC|PROCEDURE)\b', '\bDCL\b', '\bEND\b']
      Fl: xprop
  PL/SQL:
    description: |-
      PL/SQL is Oracle's procedural extension to SQL, used for stored
      procedures, triggers, packages, and other database-resident logic in
      Oracle Database systems.
    links: {Reference: https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-language-fundamentals.html}
    source:
      Like: 'SQL-like'
      Ext: [.bod, .bdy, .fnc, .prc, .spc, .trg]
      Fl: xprop
  PODL:
    aka: ['Portal Object Definition Language']
    description: |-
      PODL is Oracle Communications Billing and Revenue Management's
      Portal Object Definition Language. It is a text-based deployment and
      interchange format used by the pin_deploy utility to export, verify,
      create, and replace field definitions and storable class definitions
      in the BRM data dictionary. Although human-readable and source-control
      friendly, it is tightly bound to Oracle BRM deployment tooling and
      data-dictionary semantics.
    links: {Reference: https://docs.oracle.com/en/industries/communications/billing-revenue/15.1/dev-guide/creating-custom-fields-and-storable-classes1.html, Utility: https://docs.oracle.com/en/industries/communications/billing-revenue/15.1/dev-guide/developer-utilities1.html}
    source:
      Ext: [.podl]
      Require: ['\b(?:SQL_STORAGE|PIN_FLD_|pin_deploy|storable class|field definitions)\b']
      Fl: xprop
  Polly:
    description: |-
      Polly was a small, logic-less HTML templating language for Rust server
      applications. It used .polly templates with slash-prefixed HTML
      elements, component calls, variables, and Rust-provided functions to
      generate localized HTML output. The project appears to have remained an
      obscure abandoned implementation rather than a broadly used templating
      ecosystem. Inactive since 2018. Nore that there are twoo other languages
      named "Polly", one deployed at Amazon and one associated with LLVM.
    links: {Repository: https://gitlab.com/Polly-lang/Polly}
    source:
      Ext: [.polly]
      Str: [['"', '"', bse]]
      Co: ['$std.if', '$std.each', '@', '&']
      Fl: xdead
  PowerBuilder:
    description: |-
      A programming environment and language used for building
      database-driven business applications with a strong emphasis on rapid
      application development and data-centric user interfaces. It is
      centered around visual components and tightly integrated data access
      mechanisms.
    links: {Website: https://www.appeon.com/products/powerbuilder.html}
    source:
      Like: 'Pascal-like'
      Ext: [.pbl, .pbt, .srw, .sru, .srp]
      Fl: xprop
  PRACTICE:
    description: |-
      A scripting language used in Lauterbach development tools to automate
      debugging, testing, and target control workflows in embedded systems
      environments. It is designed for low-level interaction with hardware
      and debugging infrastructure, enabling precise control over execution
      and system state.
    links: {Website: https://www.lauterbach.com/, Reference: https://www.lauterbach.com/pdf/practice.pdf}
    source:
      Like: 'assembly'
      Ext: [.cmm]
      Fl: xprop
  Progress ABL:
    description: |-
      A database storage format used by the Progress OpenEdge platform to
      persist application data, schema definitions, and transactional state
      within integrated business applications.
    links: {Website: https://www.progress.com/openedge, Reference: https://docs.progress.com/bundle/abl-reference}
    source:
      Like: 'Pascal-like'
      Ext: [.p, .w, .cls, .i]
      Bc: [['/*', '*/']]
      St: '.'
      Fl: xprop
  PureBasic:
    aka: [PureBASIC]
    description: |-
      PureBasic is a commercially distributed BASIC-derived programming
      language and IDE from Fantaisie Software for building native
      applications on Windows, Linux, macOS, and Raspberry Pi. The language
      uses structured BASIC syntax with procedures, modules, structures,
      interfaces, arrays, lists, maps, compiler directives, inline assembly,
      and a large standard command library.
    links: {Website: https://www.purebasic.com/, Reference: https://www.purebasic.com/documentation/, Source Files: https://www.purebasic.com/documentation/reference/ide_files.html}
    source:
      Ext: [.pb, .pbi, .pbf]
      Bc: [[;, "\n"]]
      Str: [['"', '"', bse]]
      St: ':'
      Require: ['\b(?:Procedure|EndProcedure|If|EndIf|For|Next|ForEach|Repeat|Until|While|Wend|Select|EndSelect|Structure|EndStructure|Interface|EndInterface|Module|EndModule|Enumeration|EndEnumeration|NewList|NewMap|Define|Global|Protected|Shared|Static|CompilerIf|CompilerEndIf)\b']
      Co: ['If ', 'ElseIf ', 'Else ', 'EndIf', 'For ', 'Next', 'ForEach ', 'Repeat', 'Until ', 'While ', 'Wend', 'Select ', 'Case ', 'Default', 'Procedure ', 'EndProcedure', 'Macro ', 'EndMacro', 'Module ', 'EndModule', 'CompilerIf ', 'CompilerElse', 'CompilerEndIf', 'And ', 'Or ', 'Not ', '<> ', '= ']
      Fl: xprop
  Q (kdb+):
    description: |-
      A concise, array-oriented programming language designed for
      high-performance data processing and analysis, particularly in
      time-series and financial domains. It emphasizes vector operations and
      expressive query capabilities over large in-memory datasets.

      Documentation:
      https://code.kx.com/q/
    source:
      Like: 'APL'
      Ext: [.q]
      Fl: xprop
  QuakeC:
    description: |-
      QuakeC is the C-like compiled scripting language created by id Software
      for Quake game logic. QuakeC source is compiled into progs.dat bytecode
      executed by the Quake virtual machine, and is used for monsters,
      weapons, triggers, player logic, physics hooks, and other modifiable
      gameplay behavior. It is tightly bound to Quake-family game engines.
    links: {Manual: https://usdqc.github.io/quakec-resources/qcmanual.html, Source: https://github.com/id-Software/Quake/tree/master/qw-qc, Valve QC: https://developer.valvesoftware.com/wiki/QC}
    source:
      Ext: [.qc, .qh]
      Like: 'C-like'
      St: ;
      Require: ['^\s*\.?(?:float|vector|string|entity|void)\b|\b(?:self|other|world|time|frametime|nextthink|think|touch|use|precache_model|precache_sound|setmodel|setorigin|setsize|traceline|walkmove|dprint|stuffcmd)\b']
      Co: ['if ', if(, 'else ', 'while ', while(, 'do ', 'return ', 'local ', 'float ', 'vector ', 'string ', 'entity ', 'void ', 'self', 'other', 'world', '&& ', '|| ', '!= ', '== ']
      Fl: xdsl
  Red:
    description: |-
      Red is a language and toolchain descended from Rebol, designed to span
      systems programming and high-level scripting with a compact runtime and
      dialecting facilities.
    links: {Reference: https://github.com/red/red}
    source:
      Ext: [.red]
      Fl: xdead
  Redscript:
    description: |-
      A scripting language used for modding and extending behavior in games
      built on CD Projekt RED’s REDengine, enabling modification of gameplay
      logic and systems through external script files. While REDengine is proprietary,
      Redscript is open source.
    links: {Reference: https://wiki.redmodding.org/redscript/, Repository: https://github.com/jac3km4/redscript}
    source:
      Like: 'C-like'
      Ext: [.reds]
      Co: ['for ', '@if(', 'switch ', 'while ', 'else ', 'func ', '-> ']
  ShaderLab:
    description: |-
      A domain-specific language used in the Unity engine to define
      rendering behavior, combining high-level structure with embedded GPU
      programs and rendering state declarations. It acts as a container for
      shader passes, material properties, and platform-specific
      implementations within Unity’s rendering pipeline.

      Reference::
      https://docs.unity3d.com/Manual/SL-Reference.html +
    source:
      Like: 'C'
      Ext: [.shader]
      Fl: xtpl|xprop
  SKILL:
    description: |-
      SKILL is a Lisp-family scripting language used to customize and
      automate Cadence electronic design automation (EDA) tools.  It is
      commonly used in integrated circuit design environments to generate
      layout geometry, manipulate schematics, control simulations, and
      extend tool functionality.
    links: {Introduction: https://en.wikipedia.org/wiki/Cadence_SKILL}
    source:
      Like: 'Lisp-like'
      Ext: [.il]
      Co: ['for ', 'for(', 'if ', 'if(', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xhdl|xprop
  SKILL++:
    description: |-
      SKILL++ is an object-oriented extension of the SKILL language used
      within Cadence electronic design automation tools for scripting and
      customization of design environments. It augments the base language
      with class-based programming, method dispatch, and encapsulation
      features while retaining a Lisp-like syntax.
    links: {Reference: https://community.cadence.com/cadence_blogs_8/b/cic/posts/skill-for-the-skilled-introduction-to-skill}
    source:
      Like: 'Lisp-like'
      Ext: [.ils]
      Fl: xhdl|xprop
  Softbridge BASIC:
    description: |-
      Softbridge BASIC is a structured BASIC dialect in the developed for
      business and database application development on microcomputers in the
      1980s. It was part of the Softbridge Information Management System
      environment and was designed to support the construction of
      data-oriented business software with integrated database access and
      screen handling facilities. The language was used primarily in
      commercial application development systems distributed by Softbridge
      Microsystems.
    links: {Introduction: https://en.wikipedia.org/wiki/Softbridge_BASIC}
    source:
      Like: 'BASIC-like'
      Ext: [.sbl]
      Fl: xprop|xdead
  SPL:
    description: |-
      SPL is a search and analytics language used for querying, filtering,
      transforming, and aggregating machine-generated data in log analysis
      and observability systems. It is commonly associated with workflows
      that process event streams, enabling users to compose pipelines of
      operations to extract insights from large datasets.
    links: {Reference: https://docs.splunk.com/Documentation/Splunk/latest/SearchReference/WhatsInThisManual, Website: https://www.splunk.com/}
    source:
      Like: 'SQL-like'
      Ext: [.spl]
      Co: ['construct', 'foreach', 'map', 'while', 'if', 'include', 'catch', 'and', 'or', 'not', 'call', '<|', '<{', 'dup', 'swap']
      Fl: xprop
  SQF:
    description: |-
      SQF (Status Quo Function) is the scripting language used by the
      Arma game series for mission logic, AI behavior, and gameplay
      automation inside that engine.
    links: {Reference: https://community.bistudio.com/wiki/SQF_Syntax}
    source:
      Ext: [.sqf]
      Fl: xprop
  Stata:
    description: |-
      Stata is the command, scripting, and statistical analysis language used
      by the Stata software environment for data management, estimation, and
      reproducible analysis workflows.
    links: {Reference: https://www.stata-press.com/manuals/programming-reference-manual/}
    source:
      Ext: [.do, .ado, .mata]
      Fl: xmat|xprop
  Teamcenter MET:
    description: |-
      A metadata exchange format used within Siemens Teamcenter environments
      to define structured attribute mappings and data transfer behavior
      between systems and integrations. It is typically used in enterprise
      PLM workflows to coordinate how information is interpreted across
      connected tools and services.
    links: {Reference: https://docs.sw.siemens.com/en-US/doc/209349590/PL20200501135844554.integration_tc_icc/data_exchange_met_files}
    source:
      Like: 'INI'
      Ext: [.met]
      Fl: xcfg|xprop
  Teamcenter MTH:
    description: |-
      A configuration format used within Siemens Teamcenter integration
      workflows to define transformation and mapping behavior applied during
      data exchange operations between Teamcenter and external systems.
    links: {Reference: https://docs.sw.siemens.com/en-US/doc/209349590/PL20200501135844554.integration_tc_icc/data_exchange_mth_files}
    source:
      Like: 'INI'
      Ext: [.mth]
      Fl: xcfg|xprop
  Tiger:
    description: |-
      Tiger is a small imperative language designed for use in Andrew
      W. Appel’s compiler textbooks and related teaching materials. Programs
      are built from expressions and declarations, with constructs such as
      let…in…end blocks used to introduce local declarations. Functions are
      declared with function and variables with var, while types are
      introduced with type declarations that may describe records or
      arrays. Control structures include if…then…else expressions, while and
      for loops, and break for loop termination. Record construction uses
      brace notation with named fields, arrays are created with array type
      constructors, and field or element access uses dot and bracket
      syntax. The language includes primitive types such as int and string,
      supports nested functions and lexical scoping, and relies on
      expression-oriented evaluation where most constructs produce values.
    links: {Reference: https://www.cs.princeton.edu/~appel/modern/, Repository: https://github.com/andrew-appel/tiger}
    source:
      Ext: [.tig]
      Bc: [['/*', '*/'], ['//', "\n"]]
      Str: [['"', '"'], ['''', '''']]
  TNSDL:
    description: |-
      TNSDL (TeleNokia Specification and Description Language) refers
      to Telelogic or telecom-oriented SDL tooling in a proprietary
      environment, an implementation of the ITU-T SDL-88 standard.
    source:
      Ext: [.sdl]
      Bc: [[--, "\n"]]
      Str: [['"', '"']]
      Fl: xprop
  TUTOR:
    description: |-
      TUTOR was the authoring language used by the PLATO computer-based
      education system, developed at the University of Illinois. It was
      designed specifically for building interactive instructional content,
      including lessons, drills, simulations, and assessments, with strong
      support for graphics, touch interaction, and real-time feedback. The
      language integrated tightly with the PLATO runtime environment,
      enabling rich, stateful interactions between learners and
      courseware. It was widely used in educational computing from the 1960s
      through the 1980s and played a significant role in early online
      learning systems.
    links: {Introduction: https://en.wikipedia.org/wiki/TUTOR_(programming_language)}
    source:
      Ext: [.tutor]
      Bc: [['*', "\n"]]
      St: ';'
      Str: [['"', '"']]
      Fl: num|xssep|xdead
  UMPL:
    aka: ['Unnamed Meme Programming Language']
    description: |-
      UMPL (Unnamed Meme Programming Language) is an experimental,
      open-source programming language implemented in Rust.  Its own
      documentation describes it as a deliberately unstable "meme
      programming language" with verbose syntax combining Lisp-like
      expression forms with keyword-heavy, C-like control structures.
    links: {Repository: https://github.com/mendelsshop/UMPL, Reference: https://github.com/mendelsshop/UMPL/blob/main/grammer.md}
    source:
      Ext: [.umpl]
      Bc: [['!', "\n"]]
      Str: [['`', '`', ml|bse]]
  Up:
    description: |-
      Up is an experimental interpreter language intended to explore
      Python-like ease of use with Go-like concurrency, lightweight
      threads, dynamic typing, and optional variable-level type
      annotations. The project README explicitly describes it as
      experimental and work in progress.
    links: {Repository: https://github.com/KennethanCeyer/up}
    source:
      Like: 'Go-like'
      Ext: [.up]
      Bc: [['//', "\n"]]
      Str: [['"', '"']]
      Co: ['for ', 'if ', 'else ', 'try ', 'catch ', 'throw ', 'func ', 'up ', 'return ']
  USS:
    description: |-
      Unity Style Sheets is a stylesheet format used in the UI Toolkit of
      the Unity proprietary langage to define the visual styling of user interface
      elements. It provides a styling system inspired by web technologies
      and is applied to interface structures defined separately, enabling
      consistent presentation and theming within Unity applications.
    links: {Reference: https://docs.unity3d.com/Manual/UIE-USS.html}
    source:
      Like: 'CSS'
      Ext: [.uss]
      Require: ['\b(?:-unity-|unity-)', '\bflex\b', '\bvisual-element\b']
      Fl: xprop
  Unity Prefab:
    description: |-
      Unity Prefab files are serialized asset definitions used by the Unity
      game engine to store reusable object hierarchies, component settings,
      and scene fragments.
    source:
      Like: 'YAML-like'
      Ext: [.prefab]
      Require: ['^%YAML|^%TAG !u!|^--- !u![0-9]+ &[0-9-]+']
      Fl: xcfg|xprop
  Unreal Developer Markdown:
    description: |-
      Unreal Developer Markdown is a documentation-oriented text format used
      within Unreal Engine tooling and content pipelines rather than a
      general-purpose programming language.
    source:
      Like: 'Markdown'
      Ext: [.udn]
      Require: ['^Availability:|^Title:|^Crumbs:|^Description:']
      Fl: doc|xprop
  Unreal Plugin:
    description: |-
      Unreal Plugin files are Unreal Engine plugin metadata and configuration
      documents that describe plugin identity, modules, dependencies, and
      packaging information.
    source:
      Like: 'JSON-like'
      Ext: [.upluginy]
      Require: ['"FileVersion"|"(?:FriendlyName|VersionName|Modules|CanContainContent|EnabledByDefault)"']
      Fl: xcfg|xprop
  Unreal Project:
    description: |-
      Unreal Project files are Unreal Engine project metadata documents that
      describe modules, build settings, plugins, and other project-level
      configuration.
    source:
      Like: 'JSON-like'
      Ext: [.uproject]
      Require: ['"FileVersion"|"(?:EngineAssociation|Modules|Plugins|TargetPlatforms|DisableEnginePluginsByDefault)"']
      Fl: xcfg|xprop
  Unreal Script:
    description: |-
      UnrealScript was the proprietary scripting language used by older
      generations of the Unreal Engine to express gameplay logic and object
      behavior.
    source:
      Like: 'C-like'
      Ext: [.uc]
      Str: [['"', '"', bse], ["'", "'"]]
      St: ';'
      Require: ['\bclass\b|\bstate\b|\bdefaultproperties\b|\bextends\b']
      Fl: xprop
  Unreal Shader:
    description: |-
      Unreal Shader refers to shader source used in the Unreal Engine tool
      chain and rendering pipeline, typically in engine-specific formats or
      wrappers around shader code.
    source:
      Like: 'HLSL'
      Ext: [.usf]
      Require: ['#include|#pragma|cbuffer|[Ff]loat[234]|RWTexture|Texture2D']
      Fl: xcpp|xshd|xprop
  Unreal Shader Header:
    description: |-
      Unreal Shader Header files package declarations and shared definitions
      for Unreal Engine shader sources in that engine's rendering toolchain.
    source:
      Like: 'HLSL'
      Ext: [.ush]
      Require: ['#include|#pragma|cbuffer|[Ff]loat[234]|RWTexture|Texture2D']
      Fl: xcpp|xshd|xprop
  UXML:
    description: |-
      UXML is a proprietary user interface markup format used in Unity’s UI
      Toolkit to define visual layouts and element hierarchies for
      application interfaces. It enables developers to describe interface
      structure declaratively and bind it to styling and behavior within the
      Unity runtime environment.
    links: {Reference: https://docs.unity3d.com/Manual/UIElements.html, Repository: https://github.com/Unity-Technologies/UnityCsReference}
    source:
      Like: 'XML-like'
      Ext: [.uxml]
      Fl: xprop
  VB6:
    description: |-
      VB6 is Visual Basic 6, the classic pre-.NET Visual Basic language and
      development environment used for Windows desktop applications and COM
      components.
    source:
      Like: 'VBA-like'
      Ext: [.bas, .cls, .frm, .vbp]
      Fl: xprop|xdead
  VBA:
    description: |-
      Visual Basic for Applications is an embedded automation language used
      to extend and control host applications through their exposed object
      models. It is most commonly associated with office productivity
      environments, where it is used to script workflows, manipulate
      documents programmatically, and build interactive macros tightly
      integrated with application features.
    links: {Reference: https://learn.microsoft.com/en-us/office/vba/api/overview/, Repository: https://github.com/MicrosoftDocs/VBA-Docs}
    source:
      Like: 'VBA-like'
      Ext: [.bas, .cls, .frm]
      Require: ['^\s*(?:Sub|Function|Property\s+(?:Get|Let|Set))\b', '^\s*End\s+(?:Sub|Function|Property)\b']
      Co: ['for ', 'for(', 'if ', 'if(', 'elseif ', 'switch ', 'while ', 'else ', '|| ', '&& ', '!= ', '== ']
      Fl: xprop
  Visualforce Component:
    description: |-
      A reusable UI unit in the Salesforce platform that encapsulates
      presentation structure and server-side behavior, enabling modular
      composition of application interfaces within that ecosystem.

      Introduction::
      https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_intro.htm

      Reference::
      https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_compref.htm +
    source:
      Like: 'HTML-like'
      Ext: [.component]
      Fl: xtpl|xprop
  Visualforce Page:
    description: |-
      A server-rendered page definition used within the Salesforce platform
      to construct user interfaces backed by Apex controllers and platform
      data. It forms the primary mechanism for building dynamic web views in
      legacy and hybrid Salesforce applications.

      Introduction:
      https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_intro.htm

      Reference:
      https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_compref.htm
    source:
      Like: 'HTML-like'
      Ext: [.page]
      Fl: xtpl|xprop
  Visual Studio Project:
    description: |-
      Visual Studio Project files are MSBuild- and IDE-oriented project
      definition documents describing source files, references, build
      settings, and tool integration for a project.
    links: {Reference: 'https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild?view=visualstudio'}
    source:
      Like: 'XML-like'
      Ext: [.csproj, .vbproj, .vcxproj, .fsproj]
      Fl: xbld|xprop
  Visual Studio Solution:
    description: |-
      Visual Studio Solution files are workspace-level documents that group
      projects and record build configurations, project relationships, and
      IDE metadata for Visual Studio.
    links: {Reference: 'https://learn.microsoft.com/en-us/visualstudio/extensibility/internals/solution-dot-sln-file?view=vs-2022'}
    source:
      Ext: [.sln]
      Fl: xbld|xprop
  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: xtpl
  Wenyan:
    description: |-
      Wenyan is an esoteric programming language that uses Classical Chinese
      style writing to express programs. Inactive since 2021.
    links: {Reference: https://github.com/wenyan-lang/wenyan}
    source:
      Ext: [.wy]
      Bc: [['(?:批|注|疏)曰(?:。)?「「', '」」。', re], ['(?:批|注|疏)曰(?:。)?「「', '」」', re]]
      Str: [['「「', '」」']]
  Windows Message:
    description: |-
      Windows Message files define message identifiers and message text used
      by Windows tooling for event logs, system diagnostics, and generated
      resource artifacts. There is a GNU windmc utility that manipulates these
      files, but this format heavily tied to Windows and not used on Unix systems.
    links: {Reference: https://learn.microsoft.com/en-us/windows/win32/winmsg/about-messages-and-message-queues}
    source:
      Ext: [.mc]
      Bc: [[;, "\n", sol]]
      Str: [['"', '"']]
      Require: ['^\s*(?:MessageIdTypedef|SeverityNames|FacilityNames|LanguageNames|OutputBase|MessageId|Severity|Facility|SymbolicName|Language)\s*=']
  Windows Module Definition:
    description: |-
      Windows Module Definition files describe exported symbols, library
      names, sections, and linker directives for Windows DLL and executable
      builds. The open-source GNU dlltool nanipulates these files, but the
      format is heavily ties to Windows and not found on Unix systems.
    links: {Reference: 'https://learn.microsoft.com/en-us/cpp/build/reference/module-definition-dot-def-files?redirectedfrom=MSDN&view=msvc-170'}
    source:
      Ext: [.def]
      Bc: [[;, "\n", sol]]
      Str: [['"', '"']]
      Require: ['^\s*(?:LIBRARY|NAME|EXPORTS|HEAPSIZE|STACKSIZE|SECTIONS|STUB|VERSION)\b']
      Fl: xbld
  Windows Resource Script:
    description: |-
      Windows Resource-Definition Script is a format used to describe
      graphical and binary resources that are compiled into Windows program
      images. It enables the specification of user interface elements,
      localized data, and other resources that are bound into executables
      during the build process. GNU winres manipulates these files, but the
      format is havily tied to Windowa and not found on Unix systems.
    links: {Reference: https://learn.microsoft.com/en-us/windows/win32/menurc/resource-files}
    source:
      Ext: [.rc]
      Bc: [['/*', '*/'], ['//', "\n"]]
      Require: ['^\s*#\s*(?:include|define)\b', '\b(?:ICON|BITMAP|CURSOR|MENU|DIALOG|STRINGTABLE|VERSIONINFO|ACCELERATORS)\b']
      Str: [['"', '"', 'ml']]
      Fl: xbld
  WXML:
    description: |-
      WXML (WeiXin Markup Language) is the XML-like markup language
      used by WeChat Mini Programs to describe user interface
      structure and bind view templates to runtime data.

      Introduction:
      https://developers.weixin.qq.com/miniprogram/en/dev/framework/view/wxml/
    source:
      Like: 'XML-like'
      Ext: [.wxml]
      Fl: xtpl|xprop
  WXSS:
    description: |-
      WXSS is a proprietary stylesheet language used in WeChat Mini Programs to define
      the visual presentation of user interface components. It extends a
      CSS-like model with platform-specific features and integrates with the
      Mini Program runtime to apply styling across application views.
    links: {Reference: https://developers.weixin.qq.com/miniprogram/en/dev/framework/view/wxss/}
    source:
      Like: 'CSS'
      Ext: [.wxss]
      Require: ['\bwx:(?:import|keyframes)\b']
      Fl: xprop
  X10:
    description: |-
      X10 is an object-oriented, strongly typed programming language created
      by IBM Research for high-performance parallel and distributed
      computing. It extends a Java-like class-based core with the APGAS
      programming model, adding places, activities, clocks, distributed
      arrays, and constructs such as async, finish, at, atomic, and when for
      expressing locality, concurrency, and coordination. It was open source,
      but the implementation and release stream appear dormant after the
      2.6.2 release in January 2019.
    links: {Website: https://x10-lang.org/, Repository: https://github.com/x10-lang/x10, Reference: https://www.classes.cs.uchicago.edu/archive/2011/winter/32102-1/reading/x10-latest.pdf}
    source:
      Ext: [.x10]
      Like: 'C-like'
      St: ;
      Co: ['async ', 'finish ', 'at ', 'atomic ', 'when ', 'clocked ', 'ateach ', 'offer ', 'offers ', 'val ', 'var ', 'def ', 'struct ', 'property ', 'for ', for(, 'if ', if(, 'switch ', 'while ', 'else ', 'try ', 'catch ', 'finally ', '|| ', '&& ', '!= ', '== ']
      Fl: xdead
  Xcode Config:
    description: |-
      Xcode configuration files are declarative build-setting documents used
      by Xcode to define compiler flags, paths, and other project build
      parameters.
    links: {Reference: https://developer.apple.com/documentation/xcode/adding-a-build-configuration-file-to-your-project}
    source:
      Ext: [.xcconfig]
      Fl: xbld|xprop
  X++:
    description: |-
      X++ is the proprietary object-oriented language used in
      Microsoft Dynamics 365 Finance & Operations (formerly Dynamics
      AX) and related ERP systems. It combines database integration,
      business logic, and application code in one environment.
    links: {Introduction: https://learn.microsoft.com/en-us/dynamics365/fin-ops-core/dev-itpro/dev-ref/xpp-language-reference}
    source:
      Like: 'C-like'
      Ext: [.xpp, .xpo]
      Fl: xprop

# EOF
