Business applications and reports on SAP systems. Its statements work with business records, database queries, internal tables, and application events. Classes and interfaces also support reusable logic within the SAP application environment.

Object-oriented scripts for Flash and AIR applications. Classes, typed variables, and event listeners organize interactive applications. Packages group related definitions, while display objects and asynchronous events connect program logic to an application's interface.

Strongly typed programming for reliable embedded systems. Explicit declarations, packages, and range constraints make program assumptions visible. Tasking supports concurrent activities, while exceptions and structured interfaces help organize larger applications with strict correctness requirements.

Windows automation with AutoHotkey v1 scripts. Hotkeys, text replacements, window commands, and control flow connect keyboard input to repeatable actions. This grammar targets version 1 syntax; version 2 has a separate entry.

Windows automation with AutoHotkey v2 scripts. Functions, expressions, objects, and hotkey definitions describe desktop workflows. Version 2 revises important language rules, so older command-style scripts may need changes before they can run.

Angular templates with bindings and event handlers. Property bindings, event listeners, and template expressions connect markup to component state. Angular-specific control flow and directives add behavior beyond ordinary HTML without turning the template into standalone JavaScript.

TypeScript components and services for Angular. Decorators, classes, imports, and typed properties describe component behavior and application services. This entry recognizes Angular-oriented TypeScript, while the separate template entry focuses on HTML bindings and markup.

Configure the Apache HTTP server. Directives and section blocks define virtual hosts, directories, access rules, and module settings. Context matters: a directive allowed in the main configuration may not be valid in every directory override.

Application logic on the Salesforce platform. Classes, triggers, and database operations implement business behavior close to Salesforce records. The syntax resembles Java, but execution follows platform transaction rules, permissions, and resource limits.

Array-oriented calculations with compact symbolic notation. Specialized symbols operate on vectors and multidimensional arrays, often expressing a whole transformation in one expression. Reading an example involves understanding array shapes, primitive functions, and evaluation order.

Automate macOS applications and workflows. Tell blocks send commands to scriptable applications, and dictionaries describe the objects each application exposes. Variables, handlers, and conditions combine these commands into repeatable desktop tasks.

A general-purpose programming language with C-like syntax. Declarations, expressions, and braced blocks organize source into familiar programming structures. This entry refers to the Ara language grammar, rather than unrelated tools that share the same name.

Structured text for documentation and publishing. Headings, lists, attributes, cross-references, and delimited blocks organize substantial documents. Authors can keep readable source files while a publishing tool produces formatted pages, books, or technical manuals.

Low-level instructions for processor programming. Labels, registers, instructions, and assembler directives expose details hidden by higher-level languages. Exact mnemonics and operand rules depend on the processor and assembler, so assembly syntax is not universal.

Web components combining HTML with script frontmatter. A frontmatter section holds component logic, followed by a template with HTML and expressions. Components can combine content and reusable markup while keeping server-side work separate from browser interactions.

Process text records and generate reports. Patterns select input records and actions process their fields. Built-in variables, regular expressions, and associative arrays make the language useful for extracting columns, summarizing files, and transforming command output.

Services and integrations for distributed applications. Services, clients, structured values, and concurrency constructs describe communication between systems. Network interactions are visible in the language, making request handling and integration flows central parts of a program.

Batch commands for Windows automation. Commands, environment variables, labels, and conditional branches automate tasks in the Windows command interpreter. Quoting and variable expansion affect how arguments are passed, especially inside loops and grouped commands.

Double-entry bookkeeping in plain-text files. Dated transactions contain postings to accounts, alongside balances, prices, and descriptive metadata. The text format supports reviewing financial records as source files while separate tools validate balances and produce reports.

Lightweight scripting for embedded systems. Functions, classes, and familiar control statements provide application scripting with a compact runtime. Its design suits embedding, where scripts interact with capabilities supplied by a host program or device.

Bibliography entries for citations and references. Each entry combines a citation key with fields such as author, title, and year. Bibliography styles determine presentation, allowing the same reference data to support different document citation conventions.

Declarative infrastructure definitions for Azure. Resources, parameters, variables, and modules describe intended Azure deployments. Expressions connect resource properties and outputs, helping organize infrastructure definitions without manually writing equivalent ARM template JSON.

Routing configuration for the BIRD 2 daemon. Protocol blocks, routing tables, and filters describe how routes are exchanged and selected. Expressions and policy rules control announcements; this entry specifically targets the BIRD 2 configuration language.

HTML templates with Laravel directives. Directives express loops, conditions, layouts, and reusable components inside HTML. Escaped output expressions insert application data, while template inheritance helps share page structure across a Laravel application.

Application scripts for the 1C:Enterprise platform. Procedures, functions, and event handlers connect business objects to application behavior. Modules run in the 1C environment, where platform objects and execution context shape database and interface operations.

Procedural programming for systems and applications. Functions, pointers, structures, and explicit memory operations give close control over data representation. Headers describe interfaces, while a compiler and linker combine source files into libraries or executable programs.

A C-like language for systems programming. The language keeps a C-like expression and statement style while adding facilities for organizing larger programs. Modules, contracts, and compile-time features aim to make systems code easier to structure.

Resource-oriented smart contracts for Flow. Resources model values whose ownership and movement require explicit handling. Contracts, transactions, and capabilities organize access to stored assets and define how applications interact with the Flow blockchain.

Programs and smart contracts for provable computation. Typed functions, structs, and modules express computations intended for a proof-oriented execution environment. Starknet contracts add platform-specific interfaces and storage, so ordinary language syntax and contract behavior remain distinct concerns.

Parallel programming for multicore and distributed systems. Arrays, domains, tasks, and locales help express computations across cores or machines. Parallel constructs are part of the language, allowing data layout and work distribution to appear directly in source.

Smart contracts for the Stacks blockchain. Lisp-like expressions define functions, persistent values, and asset operations. The language emphasizes analyzable contract behavior, with explicit types and a restricted execution model suited to on-chain application rules.

Functional programming in a JVM Lisp dialect. Lists, vectors, maps, and sets provide a compact vocabulary for immutable data. Functions and sequence operations compose transformations, while macros extend syntax and Java interoperability connects code to JVM libraries.

Cross-platform software build definitions. Commands define targets, source files, dependencies, and build options. CMake generates files for a chosen build system, separating project configuration from the commands that actually compile and link software.

Business records, transactions, and batch processing. Divisions organize program identity, environment, data definitions, and procedures. Record layouts and decimal arithmetic make business data explicit, while readable statements describe file processing and transactional workflows.

Assign reviewers to repository files and directories. Path patterns are paired with user or team identifiers to describe review ownership. Rule ordering and repository hosting behavior determine which owners apply when a change touches matching files.

Query source-code databases for analysis. Queries combine classes, predicates, and logical relationships to identify patterns in programs. The analysis runs against an extracted code database, so query results depend on the source language and database contents.

Concise scripting syntax that compiles to JavaScript. Indentation, concise function definitions, and comprehensions reduce punctuation in scripts. Compilation produces JavaScript, so the resulting program still depends on JavaScript semantics and the APIs of its runtime environment.

A Lisp dialect with macros and interactive development. Parenthesized forms represent both programs and data, supporting powerful macros and interactive development. Functions, packages, classes, and conditions provide tools for building extensible applications within a running Lisp environment.

Formal proofs and dependently typed programming. Definitions, inductive types, and theorem statements connect programs with mathematical claims. Proof scripts guide the prover through obligations, and successful checking establishes a proof within the system's logical foundations.

Generic and object-oriented systems programming. Classes, templates, references, and deterministic object lifetimes support reusable abstractions with detailed resource control. The language serves applications from libraries and desktop tools to game engines and performance-sensitive infrastructure.

Ruby-like syntax compiled to native code. Type inference and static compilation combine a familiar scripting style with native executables. Classes, blocks, and macros organize programs, while compile-time checks catch many inconsistencies before execution.

Typed application development in the .NET ecosystem. Classes, records, interfaces, and generics model application data and behavior. Async methods and language-integrated queries support common workflows across web services, desktop software, games, and other .NET applications.

Layout, typography, and visual styling. Selectors choose elements and declarations assign visual properties. The cascade, inheritance, and layout systems determine how rules combine, letting one stylesheet adapt presentation across different screen sizes and document structures.

Tabular data with comma-separated fields. Rows represent records and separators divide fields. Quoted values can contain commas or line breaks, so reading a file correctly requires attention to escaping, headers, and the producer's formatting conventions.

Constraints and validation for structured data. Values and constraints share one notation, allowing configuration, validation, and schemas to be combined. Unification brings requirements together and exposes incompatible assumptions instead of relying only on imperative update steps.

Pattern-based queries for graph data. Node and relationship patterns describe the graph structures a query should match. Clauses filter, aggregate, and return results, making connections between entities visible directly in the query's notation.

Compiled systems programming with high-level features. Modules, templates, ranges, and compile-time evaluation support expressive native applications. The language combines systems-level access with higher-level facilities, allowing resource and abstraction choices to suit different parts of a program.

Typed applications for Flutter and the web. Classes, typed collections, null safety, and asynchronous functions support structured application code. Dart is widely associated with Flutter interfaces, while its compilation targets also support command-line and browser-based programs.

Formulas for calculations in tabular data models. Expressions define measures and calculated values over model tables. Row context, filter context, and relationships influence results, so a formula's meaning depends on the surrounding analytical model as well as its syntax.

Linux desktop application launchers and metadata. Section names and key-value pairs describe application names, launch commands, icons, and categories. Desktop environments read these files to present launchers and associate applications with supported document types.

Changes between versions of text files. File headers and change hunks show added, removed, and unchanged lines. Unified diffs preserve surrounding context, making them useful for code review, patch exchange, and understanding how a document evolved.

Instructions for building container images. Instructions select a base image, copy files, install dependencies, and configure startup behavior. Build stages can separate compilation from runtime contents, helping describe repeatable image construction in a readable text file.

Environment variables in a simple key-value format. Names and values provide configuration outside application source code, usually one assignment per line. Comments and quoting improve readability, but interpolation and escaping rules depend on the tool that reads the file.

Game scripts for the BYOND platform. Object paths, variables, procedures, and inheritance describe game entities and their behavior. The BYOND environment supplies world, map, and interaction facilities that connect scripts to a running multiplayer game.

Templates with expressions and directives for AdonisJS. Tags, expressions, and components combine application data with text or HTML. Layout composition and conditional rendering help organize server-generated pages in projects using Edge and the AdonisJS ecosystem.

Concurrent applications on the Erlang virtual machine. Immutable data, pattern matching, and pipelines organize transformations. Lightweight processes communicate through messages, while supervision structures help applications recover from failures within the Erlang runtime's concurrency model.

Functional programming for web interfaces. A model stores state, messages describe events, and update functions produce the next state. Static types and pure functions make interface behavior explicit, with effects handled through controlled runtime mechanisms.

Scripts and extensions for the Emacs editor. Lisp forms define functions, variables, hooks, and interactive commands. Scripts can inspect buffers, customize editing behavior, and extend the editor using the same environment in which users write and evaluate code.

Ruby expressions embedded in text and HTML templates. Special delimiters distinguish Ruby statements from expressions whose values should appear in the output. The surrounding document remains ordinary text, making ERB useful for HTML views and other generated files.

Message-passing processes and distributed systems. Pattern matching and immutable values combine with isolated processes and asynchronous messages. The language is associated with fault-tolerant services, where process supervision and distributed communication shape how systems are organized.

Lisp syntax that compiles to Lua. Parenthesized expressions and macros provide a Lisp-style layer over Lua. Compiled programs can use Lua libraries, making the language suitable for extending applications with concise, programmable syntax.

Interactive shell commands and readable scripts. Commands, pipelines, variables, and functions support everyday terminal workflows. Its scripting rules differ from POSIX shells, so a Bash script cannot always be used unchanged.

Localization messages with variables and attributes. Messages can contain variables, references, attributes, and selection expressions. Translators can adapt grammatical structure to a language instead of being limited to replacing isolated words in a fixed sentence.

Fixed-form Fortran organizes source by character columns, with dedicated positions for statement labels and continuation marks. It remains important when reading older numerical libraries and engineering programs. Leading spaces and line lengths can affect meaning, so this grammar is distinct from free-form Fortran.

Free-form Fortran removes the fixed-column layout of older source files, allowing indentation to follow program structure. Ampersands continue statements and exclamation marks introduce comments. It is common in modern scientific software using modules, procedures, and array operations to organize numerical calculations.

Functional-first programming for .NET. Type inference, pattern matching, and discriminated unions help describe data transformations clearly. Functions compose naturally, while interoperability allows programs to use existing .NET libraries and object-oriented APIs.

Serialized scenes and resources for Godot. Sections describe nodes, external resources, subresources, and stored properties. These text files capture scene or asset structure for Godot; they represent serialized data rather than executable gameplay scripts.

Gameplay scripting for the Godot engine. Indentation, functions, signals, and optional type annotations describe node behavior. Close integration with Godot's scene system makes it convenient to connect input, animation, and game state.

Shader programs for Godot materials. Shader types, uniforms, and processing functions control material appearance. The syntax resembles GLSL but follows Godot-specific stages and built-ins for spatial, canvas, and other rendering contexts.

An indentation-based language using the Vala compiler. Classes, methods, and signals use a compact indentation-based notation. Compilation through Vala connects programs to GObject and GLib, making Genie useful for applications in that ecosystem.

Readable scenarios for behavior-driven tests. Features and scenarios describe expected behavior using Given, When, and Then steps. Examples and data tables make cases concrete, while a separate test implementation supplies the executable step definitions.

Messages describing changes in Git commits. A subject line summarizes a change, followed by optional explanatory paragraphs and trailers. This entry highlights commit-message structure, helping distinguish the description from comments added by Git's editor workflow.

Instructions for reordering and editing Git commits. An interactive rebase plan lists commits with actions such as pick, reword, or squash. Editing these instructions changes how history will be replayed; the file is a plan, not ordinary source code.

Typed functional programming for concurrent applications. Typed functions, custom data types, and pattern matching make program structure explicit. The language emphasizes immutable data and composable operations, with tooling for applications that target supported runtimes such as Erlang and JavaScript.

JavaScript components with embedded Glimmer templates. Template tags embed Glimmer markup directly in JavaScript modules. Components can keep imports, helper functions, and template expressions together, making the relationship between local code and rendered UI easier to follow.

TypeScript components with embedded Glimmer templates. Glimmer templates appear alongside TypeScript declarations and component logic. The format keeps typed inputs and local helpers near their markup, while distinguishing embedded template syntax from ordinary TypeScript expressions.

GPU shaders for OpenGL graphics. Vectors, matrices, uniforms, and stage inputs describe GPU computations. Shader stages transform geometry or calculate pixel values, with available features determined by the shading-language version and graphics environment.

Build definitions for generating Ninja files. Targets, templates, variables, and dependency lists describe a build graph. GN evaluates these definitions to produce Ninja files, commonly organizing large projects with shared configurations and reusable target patterns.

Commands for plotting data and mathematical functions. Plot commands combine data sources or functions with axes, ranges, and styles. Scripts can reproduce a chart's settings and generate output for interactive viewing, documents, or automated reporting.

Compiled programs with built-in concurrency support. Packages, interfaces, and explicit error values organize application code. Goroutines and channels support concurrent work, while straightforward syntax and standard tooling help keep services and command-line programs easy to maintain.

Typed API schemas and data queries. Schemas define object types, fields, and operations, while queries select the data a client needs. Variables and fragments make requests reusable without embedding the server's resolver implementation in the query document.

Dynamic scripting and applications on the JVM. Closures, collections, and flexible object syntax support scripts and domain-specific languages. Java interoperability lets Groovy work with JVM libraries, including application code and build automation tools.

Typed application code for the HHVM runtime. Type annotations, collections, and asynchronous functions extend a PHP-related programming model. The language is designed for HHVM applications, so its syntax and runtime assumptions should not be confused with standard PHP.

Indentation-based templates for HTML. Indentation defines element nesting, with shorthand for attributes and embedded Ruby expressions. The source emphasizes document structure while a template engine generates the corresponding HTML.

Text templates with expressions and helpers. Double-brace expressions insert values, and block helpers describe repeated or conditional sections. Partials support reusable fragments, keeping presentation templates separate from the application code that prepares their data.

Pure functional programming with lazy evaluation. Functions, algebraic data types, and type classes describe computations with strong static checks. Lazy evaluation delays work until needed, while explicit effect abstractions distinguish pure transformations from interactions with the outside world.

Typed code that compiles to multiple target platforms. Classes, enums, generics, and pattern matching describe reusable application logic. A compiler targets several platforms, so shared source can coexist with platform-specific APIs and conditional compilation where needed.

Structured configuration for HashiCorp tools. Blocks, attributes, and expressions provide a readable configuration notation. The application using HCL defines the allowed block types and meaning, so identical syntax can describe different systems in different tools.

Readable JSON-style data with comments. Optional quotes, comments, and relaxed separators reduce punctuation in hand-edited configuration. The resulting data still uses familiar objects and arrays, but the source should not be assumed valid for a strict JSON parser.

GPU shaders for DirectX applications. Typed vectors, matrices, textures, and shader entry points describe graphics computations. Semantics connect program values to pipeline inputs and outputs, with capabilities depending on the target shader model.

Structure and content for the web. Elements and attributes describe headings, links, forms, media, and other document content. Semantic markup gives browsers and assistive technologies meaningful structure, while CSS and JavaScript supply styling and interactive behavior.

HTML-based markup used by template languages. This grammar covers HTML-derived source used by templating systems rather than a separate standardized language. Tags and attributes provide the base structure, while additional expressions depend on the particular template engine.

HTTP requests, response headers, and message bodies. Methods, status lines, headers, and message bodies describe communication between clients and servers. Textual examples help inspect request structure and response metadata, even when actual transport uses a binary protocol version.

HTTP requests with response assertions for testing. A text file combines HTTP requests with checks on status codes, headers, and response content. Variables and captures connect steps, making repeatable API checks readable alongside the requests they exercise.

Compiler options and build targets for Haxe. Lines specify source paths, libraries, defines, and compilation targets for the Haxe compiler. A project can store repeatable build arguments in one file instead of reconstructing a long command line.

Lisp expressions running in the Python ecosystem. Parenthesized forms express Python operations through a Lisp-style syntax. Macros can transform code, while interoperability keeps Python modules and objects available within the same underlying ecosystem.

Web interfaces with integrated markup and styling. The language brings component markup and styling close to application logic. Its integrated syntax targets interactive web development, letting developers describe elements and their behavior within a cohesive source structure.

Section-based configuration with key-value pairs. Section headers group named settings, usually written as key-value assignments. The format is easy to edit, but comments, quoting, and repeated-key behavior vary because implementations do not share one universal specification.

Typed, object-oriented applications on the JVM. Classes, interfaces, packages, and generics organize programs with static type checking. Bytecode runs on a compatible JVM, making libraries and runtime facilities important parts of application portability.

Python-oriented templates with expressions and blocks. Expressions insert values, while blocks provide conditions, loops, macros, and inheritance. Filters transform displayed values, helping generate HTML or other text from application data without duplicating whole templates.

Grammar and lexer rules for JavaScript parsers. Lexical patterns identify tokens and grammar productions describe valid combinations. Semantic actions attach behavior to parsed structures, allowing a grammar file to become a JavaScript parser through code generation.

Structured data and configuration. Objects, arrays, strings, numbers, booleans, and null form a small interchange vocabulary. Strict JSON requires quoted property names and excludes comments, making it distinct from JavaScript object literals and relaxed configuration variants.

JSON-style data with comments and relaxed syntax. Comments, trailing commas, and additional literal forms make hand-written configuration more convenient. It retains JSON's object and array model, but requires a JSON5-aware parser rather than a strict JSON reader.

JSON data with explanatory comments. Comments let configuration authors explain values alongside ordinary JSON structures. Acceptance of features such as trailing commas depends on the consuming tool, so JSONC files should not be treated as universally interchangeable JSON.

One JSON value per line for data streams. Each line holds one complete JSON value, allowing records to be processed incrementally. The format suits logs, exports, and pipelines where reading an entire enclosing array would be inconvenient.

Programmable data templates for configuration. Functions, imports, and object composition turn configuration into reusable data-producing programs. Evaluation generates concrete JSON, separating shared definitions and parameters from the final documents consumed by other systems.

Finite-state machines written in the FSL language. FSL statements describe states, transitions, and actions using a compact graph-like notation. The JSSM library interprets those definitions as a state machine, keeping transition rules separate from surrounding application logic.

JavaScript with XML-like UI markup. Markup-like elements appear inside JavaScript expressions, with braces embedding dynamic values. A transformation step converts this syntax into ordinary JavaScript calls; JSX is not HTML sent directly to the browser.

Numerical and scientific computing with dynamic syntax. Multiple dispatch selects methods according to argument types, while arrays and mathematical notation support numerical work. Interactive exploration and compiled execution coexist, making the language useful for research and reusable computational libraries.

Project commands organized as reusable recipes. Recipes name project commands and can accept parameters or depend on other recipes. Variables and settings keep repeated tasks together, providing a convenient command runner rather than a file-timestamp-based build system.

Node-based documents for configuration and data. Named nodes contain arguments, properties, and optional child nodes. The notation combines ordered values with hierarchical structure, making it useful for configuration and documents that benefit from a readable tree representation.

Typed applications for JVM and multiplatform targets. Null safety, data classes, extension functions, and concise expressions support application development. Coroutines organize asynchronous work, while interoperability and multiplatform tooling connect shared logic to different runtime environments.

Queries for logs, telemetry, and analytical data. Tabular operators filter, project, join, and summarize records through pipelines. The query style suits exploring large event datasets, where time ranges and aggregations reveal patterns in operational or analytical information.

Structured typesetting for scientific documents. Commands and environments describe sections, equations, references, and document structure. Packages extend typesetting features, allowing authors to focus on logical organization while a TeX-based toolchain handles layout and output.

Functional programming and machine-checked proofs. Definitions and theorem statements share a dependently typed language. Proof terms or tactics discharge mathematical obligations, while executable functions allow formal reasoning and ordinary programming to coexist in a checked environment.

CSS extended with variables and mixins. Variables, mixins, nesting, and functions reduce repeated stylesheet rules. A compiler produces ordinary CSS, so browser behavior follows the generated stylesheet rather than executing Less expressions directly.

Templates with filters, loops, and conditions. Output expressions display values, tags control document flow, and filters transform presentation. The template language is used in publishing and commerce systems where available objects are defined by the hosting application.

Intermediate representation for compiler toolchains. Typed instructions, basic blocks, and SSA values represent programs between source languages and machine code. The textual form is useful for inspecting optimization results and understanding compiler transformations.

Application events, timestamps, and severity levels. Entries often combine timestamps, severity labels, component names, and free-form messages. This is a general highlighting category rather than one universal log standard; exact fields depend on the emitting application.

Educational programming with turtle graphics. Procedures and lists support experiments with computation, often through commands that move a drawing turtle. Its interactive style helps learners connect instructions, repetition, and geometric results.

Lightweight scripting embedded in applications. Tables represent collections and objects, while functions and coroutines support flexible control flow. A compact runtime makes Lua practical for applications that expose their own features to embedded scripts.

A Lua-derived language with gradual typing. Type annotations and analysis tools extend Lua-style scripting for larger codebases. It is used in Roblox and other embeddings, where host-provided APIs determine the objects and services scripts can access.

Targets and dependencies for build automation. Rules connect targets to prerequisites and shell recipes. File timestamps help decide which work needs repeating, while variables and pattern rules reduce duplication across related compilation or generation tasks.

Lightweight text formatting for notes and documents. Headings, lists, links, emphasis, and code blocks remain readable in plain text. Renderers turn the source into formatted documents, with some features varying between CommonMark and platform-specific extensions.

HTML-based templates and reactive UI components. Tags, expressions, and component constructs combine document structure with application behavior. The compiler processes templates into rendering code, supporting reusable interfaces without treating every element as a separate handwritten function call.

Matrix operations, numerical analysis, and plots. Arrays are central to the language, with functions for manipulating data and expressing numerical algorithms. Scripts and function files support exploratory analysis, while toolboxes add specialized engineering and scientific capabilities.

Markdown extended with Vue components. Component blocks, properties, and slots enrich ordinary Markdown documents. The syntax is associated with Nuxt Content, allowing authored pages to combine prose with reusable Vue components and structured content.

Markdown documents with embedded JSX components. Authors can import components and embed expressions alongside headings, paragraphs, and code blocks. A compilation step connects the document to its component framework, making MDX useful for interactive documentation.

Text descriptions of diagrams and flowcharts. Diagram-specific statements describe nodes, connections, participants, or events. A renderer lays out the visual result, letting diagrams live beside documentation as editable text that can be reviewed in version control.

Assembly instructions for the MIPS architecture. Registers, labels, arithmetic instructions, and branches describe operations for MIPS processors. Addressing conventions and assembler directives matter when reading examples, especially when a teaching simulator provides its own system-call interface.

A Python-like language for systems and numerical computing. Typed values, functions, and compile-time facilities target performance-sensitive programs with familiar indentation. Although its appearance resembles Python, its compilation model and systems features require their own language-specific understanding.

Typed programming with WebAssembly and native targets. Functions, enums, pattern matching, and inferred types support structured application logic. Packages organize reusable code, while the toolchain compiles programs for supported targets rather than treating the source as browser JavaScript.

Resource-oriented programming for smart contracts. Modules and resource-oriented types define assets and operations over them. Ownership rules constrain how values are copied or discarded, while individual blockchain platforms supply their own execution and storage environments.

Dialogue and branching stories for narrative games. Labels, dialogue commands, conditions, and choices describe interactive scenes. Scripts connect story text to game variables and branching paths, keeping narrative flow readable without requiring every interaction to be written as general-purpose code.

Processes and channels for reproducible data workflows. Processes declare work and channels connect their inputs and outputs. Workflow definitions coordinate data-driven execution, helping organize pipelines whose individual tasks may run in containers or different computing environments.

Groovy syntax used in Nextflow workflows. Groovy expressions provide calculations, collections, and helper logic within Nextflow scripts. This grammar emphasizes that embedded scripting layer, while Nextflow's process and channel constructs define the surrounding workflow behavior.

Web server routes, proxies, and connection settings. Directives inside nested contexts configure listeners, server names, locations, and upstream services. Matching and inheritance rules determine how requests are handled, so the surrounding configuration affects each individual directive.

Compiled programs with indentation-based syntax. Static types, generics, and macros combine with readable indentation. Compilation to lower-level targets supports native programs, while compile-time facilities let libraries express abstractions that fit their problem domain.

Functional expressions for reproducible environments. Expressions, attribute sets, functions, and lazy evaluation describe package and environment definitions. The language produces values used by Nix tooling, distinguishing configuration evaluation from the separate build processes it describes.

Scripts for building Windows installers. Sections, functions, variables, and installer commands describe setup and removal workflows. Scripts control files, shortcuts, dialogs, and system settings, allowing the installer interface and deployment steps to be customized together.

Shell pipelines operating on structured data. Pipelines pass records, lists, and tables rather than only unstructured text. Commands can filter and reshape named fields, making shell workflows resemble data transformations while still integrating external programs.

Object-oriented C extensions for Apple applications. Message sends, classes, protocols, and categories extend C's underlying syntax. The language is closely associated with Cocoa frameworks, where object lifetimes and runtime dispatch shape application behavior.

Combine Objective-C objects with C++ code. A single translation unit can contain Objective-C message syntax alongside C++ classes and templates. It is useful when bridging Apple-framework interfaces with existing native libraries written in C++.

Typed functional programming with pattern matching. Algebraic data types, modules, and pattern matching organize programs around explicit data structures. Type inference reduces annotations, while functions and mutable features support both functional designs and practical application code.

A data-oriented language for systems and tools. Explicit data layouts, procedures, and allocator-aware facilities support native application development. The language emphasizes straightforward control over memory and collections, fitting tools and systems where data representation matters.

Describe parametric 3D models with code. Primitive shapes, transformations, and boolean operations describe solid geometry. Parameters and modules make designs reusable, allowing dimensions and relationships to be adjusted through source rather than only direct manipulation.

Plain-text notes, outlines, and task lists. Headings organize hierarchical documents, with tables, links, properties, and source blocks adding structure. The format supports both everyday note-taking and more elaborate workflows for planning, publishing, and reproducible documents.

Structured programming with explicit declarations. Types, records, procedures, and begin/end blocks make program organization explicit. Different dialects extend the original language, so object-oriented features and library behavior depend on the chosen compiler environment.

Text processing and general-purpose scripting. Regular expressions, hashes, arrays, and flexible string operations make text-heavy tasks concise. Modules and subroutines organize larger programs, extending the language beyond one-line transformations and administrative scripts.

Server-side scripting for web applications. Functions, classes, namespaces, and arrays support request handling and application logic. PHP can be embedded in templates or used in standalone services and command-line tools, with behavior supplied by its runtime and extensions.

Typed, programmable application configuration. Properties, classes, constraints, and modules describe reusable configuration models. Evaluation produces concrete configuration data, while type checks and validation help catch incompatible values before other applications consume them.

Procedural logic for Oracle databases. Blocks combine SQL statements with variables, conditions, loops, and exception handling. Procedures, functions, and packages keep database-side logic close to the records and transactions it operates on.

Gettext translation messages and their translations. Message identifiers, translations, contexts, and plural forms organize localization entries. Comments and flags carry translator guidance, while tools compile these editable files into catalogues used by applications at runtime.

Declarative rules for application authorization. Rules express relationships between actors, actions, and resources. Queries evaluate whether those relationships permit an operation, keeping authorization policy declarative rather than scattering equivalent conditions throughout application code.

CSS syntax processed by a plugin-based toolchain. Selectors and declarations remain recognizable as CSS, while plugins can transform or extend the source. The accepted extensions depend on the configured toolchain; PostCSS itself is a processing system rather than one fixed stylesheet dialect.

M expressions for importing and transforming data. Let expressions name transformation steps over tables, lists, and records. Functions combine data acquisition and reshaping operations, forming reusable queries for analytical workflows in tools that host the M language.

Task automation with commands and object pipelines. Cmdlets, functions, and scripts pass objects through pipelines, preserving named properties between steps. The language combines administrative commands with structured control flow for managing applications, files, and system resources.

Database models and relations in Prisma schemas. Models, fields, relations, and attributes describe application data and database mappings. Generator and datasource blocks configure surrounding tooling; the schema is a model definition rather than a sequence of SQL queries.

Logic programs built from facts and rules. Facts and rules describe relationships, and queries ask which assignments satisfy them. Unification and backtracking search for solutions, offering a different programming model from manually ordered imperative instructions.

Message and service definitions for Protocol Buffers. Messages declare typed fields with numeric identifiers, and services can describe remote operations. Code generators turn these schemas into language-specific APIs, supporting structured interchange without embedding serialized bytes in the schema itself.

Compact HTML templates using indentation. Indentation expresses nested elements, with concise notation for classes, attributes, and text. Expressions and control statements generate dynamic markup, while includes and inheritance help share page layouts.

Declarative system configuration and resources. Resources declare desired states for packages, files, services, and other system components. Relationships specify ordering and notifications, allowing an agent to compare the declared configuration with the machine's actual state.

Typed functional programs that compile to JavaScript. Algebraic data types, type classes, and explicit effects support composable programs with strong static checks. JavaScript interoperability connects compiled code to browser and server libraries while preserving typed boundaries in application logic.

Python is a general-purpose language for automation, data processing, web services, and scientific work. Indentation defines blocks, while lists, dictionaries, functions, and classes organize data and behavior. Its standard library and package ecosystem support both short scripts and larger applications with reusable modules.

Declarative interfaces for Qt applications. Objects, properties, bindings, and signals describe an interface as a hierarchy. JavaScript expressions supply dynamic behavior, while Qt components connect the declarative document to rendering, input, and application services.

Module and type declarations for QML directories. Entries identify a module and describe exported QML types, versions, and optional plugins. The file tells the QML engine how a directory contributes reusable components, rather than defining the components' visual contents.

CSS-like styling for Qt widgets. Selectors and property declarations customize widget appearance, including states and subcontrols. Although the notation resembles CSS, supported properties and matching behavior are defined by Qt Widgets rather than a web browser.

Statistical analysis and data visualization. Vectors, data frames, formulas, and functions support statistical workflows. Packages extend modeling and visualization, while interactive evaluation makes it convenient to explore datasets and turn analysis steps into reusable scripts.

A Lisp-family language for programs and language tools. Modules, functions, and macros support application development and the creation of new languages. A language declaration selects the surrounding syntax and semantics, making extensible language design a central part of the ecosystem.

Expressive scripting with grammars and concurrency. Rich signatures, junctions, grammars, and object facilities support expressive programs. Built-in parsing constructs make structured text processing prominent, while concurrency features extend the language beyond traditional sequential scripting.

HTML templates with embedded C# expressions. An at-sign introduces C# expressions and directives within markup. Templates combine dynamic values, control flow, and HTML structure, with interpretation determined by the ASP.NET view or component environment hosting the file.

Type signatures for Ruby classes and methods. Signatures describe classes, modules, methods, and the types of their arguments and results. These declarations support documentation and analysis of Ruby code without providing the method implementations themselves.

Windows registry keys and values in text form. Section headers name registry keys, followed by typed value assignments or removal instructions. The text format is used for exporting and importing settings, so its contents describe system changes rather than general program logic.

Patterns for matching and extracting text. Character classes, groups, quantifiers, and assertions describe text patterns. Different engines support different features and escaping rules, so a pattern's meaning depends on the language or tool that evaluates it.

Declarative models and queries for relational data. Relations and logical definitions express data dependencies without spelling out a sequence of update steps. RelationalAI uses this language for models and queries, where rules derive information from other relations.

Assembly instructions for the RISC-V architecture. Registers, load/store instructions, arithmetic, and branches express operations from the RISC-V instruction set. Available instructions depend on selected extensions, while assembler conveniences may translate into several machine instructions.

Rust-like notation for structured data. Struct-like values, tuples, enums, and collections provide a readable serialization notation. The format suits Rust-oriented data models while remaining a data description, not a Rust source file that executes functions.

Message field definitions for ROS communication. Field types, names, and constants describe structured messages exchanged by ROS components. Interface-generation tools create language bindings, allowing publishers and subscribers to agree on the shape of transmitted data.

Structured text markup for technical documentation. Section markers, directives, roles, and explicit references provide structured authoring tools. Documentation systems such as Sphinx build on this notation to produce linked technical manuals and API documentation.

Object-oriented scripting with expressive syntax. Objects, blocks, modules, and dynamic method calls support concise application logic. The language encourages expressive APIs and reusable libraries, making it useful for web applications, automation, and text-oriented tools.

Rust combines native compilation with ownership and borrowing rules that help manage memory safely. Structs, enums, traits, and pattern matching express reusable program designs, while Result and Option make important alternatives explicit. It is used for systems software, services, and tools that need close control over resources.

Data processing and statistical analysis programs. DATA steps transform records and procedures perform analysis or reporting. Libraries, datasets, formats, and macro facilities organize repeatable workflows, particularly where structured data preparation and statistical output belong in one program.

Indented stylesheets with variables and nesting. Indentation defines nested rules without CSS-style braces and semicolons. Variables, mixins, and functions support reusable styling logic, which a Sass compiler translates into the CSS that browsers consume.

Functional and object-oriented programming on the JVM. Case classes, pattern matching, traits, and expressive types support concise models and transformations. The language combines object-oriented organization with functional techniques and interoperates with libraries in the Java ecosystem.

A compact Lisp dialect with lexical scoping. Parenthesized expressions, first-class procedures, and lexical bindings form a small expressive core. Macros and continuations support advanced abstractions, while specific implementations provide different libraries and development environments.

CSS-compatible Sass syntax with braces. Braces and semicolons preserve familiar CSS structure while adding variables, nesting, mixins, and functions. SCSS is a Sass syntax, and its extra features are compiled away before the stylesheet reaches a browser.

Database queries for the 1C:Enterprise platform. Selections, joins, conditions, and totals operate on the platform's application data. Although the notation resembles SQL, its tables and language facilities follow the 1C query environment rather than an arbitrary database dialect.

Shader properties and rendering passes for Unity. Properties, subshaders, passes, and render-state declarations organize Unity shaders. Embedded shader code performs GPU work, while ShaderLab describes how those programs and material settings participate in rendering.

Shell commands and scripts for task automation. Pipelines, redirections, variables, and control structures connect command-line programs. Quoting determines how text becomes arguments, and shell-specific extensions mean scripts may require a particular interpreter despite similar-looking syntax.

Terminal commands together with their output. Prompts, entered commands, and printed results are shown together as a transcript. This category is useful for tutorials and troubleshooting records; the complete transcript is not intended to run as a shell script.

Object-oriented programs built around message passing. Objects receive messages, blocks represent delayed computations, and classes describe shared behavior. The syntax emphasizes message composition, reflecting a programming model where interactions between objects organize the application.

Models for service APIs and their data shapes. Shapes, traits, operations, and services describe an API independently of a particular wire protocol. Generators can use the model to produce clients, servers, and documentation for multiple programming environments.

Smart contracts for Ethereum-compatible platforms. Contracts contain state variables, functions, events, and access modifiers. The language targets blockchain execution, where storage operations, transaction context, and external calls have semantics beyond ordinary application functions.

Closure Templates for generating web content. Named templates, parameters, expressions, and control structures generate reusable interface fragments. The system supports producing output for different environments, keeping presentation definitions organized independently from the data supplied to them.

Queries over RDF triples and linked data. Graph patterns match subjects, predicates, and objects across RDF datasets. Filters, optional patterns, and aggregations refine results, allowing queries to follow relationships represented by globally identified resources.

Search and aggregate event data with SPL. Search commands form pipelines that extract fields, filter events, calculate values, and summarize results. The language is designed around event investigation, making timestamps and field-based transformations central to many queries.

Query and manipulate relational database tables. Statements select, join, group, and update relational data, with separate commands defining database structures. SQL has a standard, but functions, types, and extensions vary across engines and should be interpreted in their dialect.

Connection settings for SSH client hosts. Host patterns group options such as usernames, ports, identity files, and proxies. Configuration lookup and matching rules determine which settings apply, simplifying repeated connections without embedding every option in a command.

Commands for statistical analysis and data management. Commands transform datasets, estimate models, and produce tables or graphs. Do-files record repeatable analysis steps, while macros and programming constructs help organize larger empirical research workflows.

Flexible stylesheet syntax with variables and nesting. Optional punctuation, mixins, functions, and variables provide a flexible stylesheet authoring style. The source compiles to CSS, making generated rules the final authority for how browsers display elements.

Query and manipulate data in SurrealDB. SQL-like statements work with records, fields, relationships, and structured values. Database-specific expressions and operations reflect SurrealDB's data model, so familiar SQL appearance does not imply compatibility with every relational engine.

UI components combining script, markup, and styles. Single-file components keep markup, script, and styles together. Reactive expressions and template blocks describe changing interfaces, while a compiler transforms the component source into code that updates the rendered page.

Typed applications for Apple platforms and beyond. Structs, enums, protocols, and optionals express application models with static checks. Value semantics and concurrency features support modern programs, while interoperability connects Swift to existing platform frameworks and native libraries.

Digital hardware design and verification. Modules and interfaces describe hardware, while classes, assertions, and constrained randomization support verification. The language extends Verilog, combining circuit modeling with facilities for building sophisticated simulation test environments.

Unit files for Linux services and system resources. Sections and directives describe units such as services, timers, and mounts. Dependencies and lifecycle settings tell systemd how to order and supervise resources rather than listing a sequential shell script.

Voice-command rules for Talon automation. Context rules select when spoken commands are active, and command bodies invoke actions. The notation connects recognized phrases to automation, while reusable actions and captures supply more complex behavior.

Algebraic schemas for structured, linked data. Algebraic type definitions describe how structured data is shaped and connected. The language is associated with linked-data modeling, separating schema declarations from the concrete instances that must satisfy them.

Command-based scripting for tools and automation. Commands receive words as arguments, with substitution rules connecting variables and nested commands. Procedures and control commands build larger scripts, and applications can expose their own commands through an embedded interpreter.

Typed HTML components written alongside Go. Templates combine HTML structure with Go expressions and control flow. Generation produces Go code, allowing component parameters and surrounding application logic to participate in the project's ordinary type checking and build process.

Declarative definitions of infrastructure resources. Resources, modules, variables, and outputs describe desired infrastructure. Providers interpret resource types, while planning compares configuration with tracked state to determine the operations needed for a deployment.

Typesetting commands for text and mathematics. Control sequences, groups, and macros describe typesetting behavior at a detailed level. Higher-level document systems build on TeX, while its mathematical layout and programmable expansion model underpin many technical publishing workflows.

Readable configuration with tables and typed values. Key-value assignments, tables, arrays, and explicit scalar types organize settings. The format emphasizes predictable mapping to data structures, making it useful for project manifests and other configuration that people edit directly.

TypeScript tagged templates with embedded markup. Tagged template literals can contain HTML or CSS inside TypeScript source. This grammar highlights those embedded regions alongside types and expressions; the tag function determines how the template is interpreted at runtime.

Tabular data with tab-separated fields. Each record occupies a line and tab characters separate its fields. The simple layout works well with spreadsheets and command-line tools, but producers may differ in how they handle embedded tabs or newlines.

TypeScript with JSX markup for UI components. TypeScript declarations appear alongside JSX elements and embedded expressions. Types describe component inputs and surrounding logic, while the JSX transformation creates the runtime calls required by the chosen UI framework.

Compact text notation for RDF triples. Prefixes, compact identifiers, and abbreviated statements make RDF graphs easier to write by hand. Subjects, predicates, and objects describe relationships, with literals carrying values such as strings, numbers, or language-tagged text.

PHP-oriented templates with blocks and filters. Expressions display values, tags control rendering, and filters transform output. Blocks, inheritance, and reusable fragments help organize PHP application views while keeping template structure distinct from business logic.

TypeScript adds static types to JavaScript, helping describe function parameters, objects, and module interfaces before code runs. Inference, unions, and generics express useful relationships without changing JavaScript's underlying runtime model. Projects compile or transform the source into JavaScript for their chosen environment; JSX components use the separate TSX entry.

Describe API models and service operations. Models, operations, interfaces, and decorators describe service contracts. Emitters turn those definitions into formats such as OpenAPI, helping share reusable API vocabulary without maintaining every output document by hand.

Programmable typesetting for documents and formulas. Markup, functions, and styling rules work together in one document language. Mathematical notation and programmable layout support technical publishing, while reusable definitions keep formatting decisions separate from repeated document content.

Compiled application and systems programming. Modules, structs, functions, and explicit optional results support readable native programs. The language aims for straightforward development with static checking, while its own toolchain defines compilation and platform integration.

Typed application development with GLib and GObject. Classes, interfaces, properties, and signals provide high-level syntax for native applications. Compilation produces C code and connects to GLib/GObject libraries, making Vala useful for software in the GNOME ecosystem.

Visual Basic syntax for .NET applications. Named blocks, classes, modules, and event handlers express application behavior with keyword-oriented syntax. The language uses .NET types and libraries, supporting structured programs beyond the older Visual Basic dialects it resembles.

Digital circuit descriptions and simulation. Modules, signals, assignments, and procedural blocks describe circuit behavior and structure. Simulation models time and concurrency, while synthesizable subsets can become hardware rather than sequential instructions for a conventional processor.

Strongly typed descriptions of digital hardware. Entities describe interfaces and architectures describe implementations, using signals and concurrent statements. Strong types and explicit timing semantics support simulation and hardware design, where multiple operations naturally occur in parallel.

Scripts and custom commands for the Vim editor. Expressions, functions, mappings, and automatic commands customize editing workflows. Scripts interact with buffers, windows, and options, while syntax differences between legacy Vim script and newer dialects depend on the file's context.

Single-file components with templates, scripts, and styles. Template, script, and style blocks organize a reusable interface in one source file. Reactive state connects logic to rendered markup, and the build toolchain processes each block according to its language and attributes.

Vue templates with directives and data bindings. Interpolations, directives, and event bindings extend HTML with component-aware behavior. This entry focuses on the template portion of Vue code, rather than the script and style sections of a complete single-file component.

Vue components with templates inside TypeScript functions. Functions contain Vue component logic and return templates written with the Vine syntax. The format keeps multiple components in TypeScript source while tooling transforms their embedded markup into Vue rendering behavior.

Python-like syntax for Ethereum smart contracts. Typed functions, decorators, and explicit storage declarations describe contract operations. Its restricted feature set emphasizes inspectable behavior, while execution still follows the transaction and resource model of the target blockchain.

WebAssembly instructions in readable text form. The text format describes modules, functions, memories, and stack-machine instructions. It is a readable counterpart to WebAssembly binaries, useful for studying generated code and understanding imports, exports, and low-level operations.

Programming with syntax inspired by classical Chinese. Declarations, calculations, and control flow use literary Chinese-inspired phrases and punctuation. The language explores an alternative surface notation for familiar programming ideas, with tooling translating those expressions into executable programs.

GPU shaders and compute programs for WebGPU. Typed functions, structures, resource bindings, and entry-point attributes describe GPU work. The language serves WebGPU pipelines, where address spaces and shader stages define how data is accessed and processed.

Wiki pages with headings, links, and formatting. Lightweight markers express emphasis, sections, lists, and links, while templates add reusable content. Exact features depend on the wiki engine and installed extensions, especially for embedded tags and parser functions.

Interfaces for the WebAssembly component model. Interfaces define types and functions, while worlds describe component imports and exports. The notation specifies boundaries between WebAssembly components, allowing implementations in different languages to agree on a shared contract.

Symbolic expressions and scientific computation. Symbolic expressions, patterns, and transformation rules provide a unified model for data and computation. Built-in mathematical and visualization functions support exploratory work, while functional constructs compose more elaborate analyses.

Structured documents using tags and attributes. Nested elements, attributes, namespaces, and text describe hierarchical information. Applications define the meaning of their vocabulary, while schemas can constrain document structure without making XML itself a particular application format.

Stylesheets and templates for transforming XML. Templates and XPath expressions select parts of an XML document and construct transformed output. This entry is useful for stylesheet source that describes document conversion, rather than CSS rules for browser presentation.

Readable structured data for configuration and exchange. Indentation expresses nested mappings and sequences, with scalar styles for short or multiline values. Anchors and aliases can reuse structures, making whitespace and parser-version conventions important when reading configuration files.

Scripts for customizing games and mod behavior. Variables, functions, imports, and application-provided objects describe custom behavior. It is often encountered in modding tools such as CraftTweaker, where available operations depend on the game and installed integrations.

Systems programming with explicit memory management. Explicit allocators, error unions, and compile-time evaluation make resource and failure behavior visible. The language targets native software with close control over memory layout and interoperability with existing C code.