code-languages

Structured metadata for programming languages, packaged as a typed, tree-shakeable TypeScript library.

code-languages is useful when you need a small source of truth for language names, slugs, file extensions, release metadata, websites, paradigms, logos, and reference colors in developer tools, docs sites, learning platforms, or editor-like interfaces.

Features

• TypeScript-first data model
• Zero runtime dependencies
• ESM and CommonJS builds
• Subpath imports for per-language usage
• Tree-shakeable exports
• Localized content in English, Spanish, Italian, French, German, and Portuguese
• Works in Node.js and modern bundlers

Installation

npm install code-languages

Usage

Import only the language metadata you need:

import { typescript } from "code-languages/typescript";
import { localizeLanguage } from "code-languages/i18n";

const localized = localizeLanguage(typescript, "en");

console.log(localized.name);
console.log(localized.description);
console.log(typescript.extensions);
console.log(typescript.paradigms);

Import multiple languages:

import { abap } from "code-languages/abap";
import { actionscript } from "code-languages/actionscript";

console.log(abap.version);
console.log(actionscript.extensions);

Import from the package root when bundle size is not a concern:

import {
  abap,
  actionscript,
} from "code-languages";

console.log(localizeLanguage(abap).description);
console.log(localizeLanguage(actionscript, "es").description);

API

Every language object satisfies the Language interface:

export type BaseLocale = "en" | "es" | "it" | "fr" | "de" | "pt";
export type Locale = BaseLocale | `${BaseLocale}-${string}` | string;

export interface LanguageContent {
  name: string;
  description: string;
  longDescription: string;
}

export type LanguageStatus = "active" | "experimental" | "legacy" | "historical";

export interface Language {
  slug: string;
  aliases?: string[]; // lookup aliases, e.g. ["golang"] for go
  status?: LanguageStatus; // absent means "active"
  relations?: {
    supersetOf?: string[]; // e.g. TypeScript → ["javascript"]
    dialectOf?: string[]; // e.g. T-SQL → ["sql"]
    compilesTo?: string[]; // e.g. Elm → ["javascript"]
  };
  publishedDate: string;
  extensions: string[];
  author: string;
  website: string;
  paradigms: string[];
  tooling?: {
    runtimes?: string[];
    packageManagers?: string[];
    ecosystems?: string[];
  };
  version: string;
  logo: string;
  color: `#${string}`;
  i18n: {
    en: LanguageContent;
    es?: LanguageContent;
    it?: LanguageContent;
    fr?: LanguageContent;
    de?: LanguageContent;
    pt?: LanguageContent;
  };
}

Use the fluent API when you want one entry point for localization, dynamic loading, and filename detection:

import { api } from "code-languages/api";

const astro = api.language("astro").locale("es-PE").get();
const vue = await api.language("vue").locale("en-US").load();
const detected = api.detect("src/App.vue").locale("es").get();
const ambiguous = await api.detectAll("include/config.h").locale("en").load();

console.log(astro?.resolvedLocale); // "es"
console.log(vue?.slug); // "vue"
console.log(detected?.name); // "Vue"
console.log(ambiguous.map((language) => language.slug)); // ["c", "cpp"]

api.language(...) normalizes lookup values to the package slug format, so inputs such as "Visual Basic" and "Jupyter Notebook!" resolve to visual-basic and jupyter-notebook. Language aliases are resolved before normalization, so "golang", "C#", "F#", "C++", "wasm", or "elisp" find go, csharp, fsharp, cpp, webassembly, and emacs-lisp. When the slug is a known literal, get() and load() are typed as always returning a language — no undefined check needed.

get() reads from the bundled in-memory catalog. load() uses explicit dynamic imports so bundlers can lazy-load individual language modules when the consumer build supports code splitting.

Use api.runtime(value) to query languages that run on a specific platform or runtime environment:

import { api } from "code-languages/api";

// Get runtime metadata
const info = api.runtime('node').info();
// {
//   slug: 'node',
//   name: 'Node.js',
//   color: '#339933',
//   logo: 'https://cdn.simpleicons.org/nodedotjs',
//   website: 'https://nodejs.org',
//   aliases: ['node', 'nodejs', 'node.js'],
//   packageManagers: ['npm', 'pnpm', 'Yarn', 'Bun'],
// }

// Get languages that target this runtime
const langs = api.runtime('node').langs().get();
const langsEs = api.runtime('.net').langs().locale('es').get();
await api.runtime('jvm').langs().load();

// Returns undefined / [] for unknown values
api.runtime('unknown-xyz').info();         // undefined
api.runtime('unknown-xyz').langs().get();  // []

Supported runtime aliases include: node / nodejs / node.js, bun, deno, browser, .net / dotnet, jvm / java, android, ios, python, ruby, rust, go / golang, wasm, sql, and many more. Searches tooling.runtimes and tooling.ecosystems on each language.

Use api.packageManager(value) to query languages that use a specific package manager:

import { api } from "code-languages/api";

// Get package manager metadata
const info = api.packageManager('npm').info();
// {
//   slug: 'npm',
//   name: 'npm',
//   color: '#CB3837',
//   logo: 'https://cdn.simpleicons.org/npm',
//   website: 'https://npmjs.com',
//   aliases: ['npm'],
// }

// Get languages that use this package manager
const langs = api.packageManager('cargo').langs().get();
const langsEs = api.packageManager('pip').langs().locale('es').get();

// Get runtime platforms that include this package manager
const runtimes = api.packageManager('npm').runtimes();
// [{ name: 'Node.js', ... }, { name: 'Bun', ... }, { name: 'Deno', ... }]

// Returns undefined / [] for unknown values
api.packageManager('unknown-xyz').info();      // undefined
api.packageManager('unknown-xyz').langs().get(); // []
api.packageManager('unknown-xyz').runtimes();  // []

Supported package manager aliases include: npm, pnpm, yarn, pip, poetry, uv, cargo, maven, gradle, nuget, composer, hex, spm, rubygems, go-mod, luarocks, opam, cpan, and more. Searches tooling.packageManagers on each language.

Use api.category(value) to filter languages by their domain of use:

import { api, getCategories } from "code-languages";

// frontend  — targets the browser only (CSS, HTML, WGSL…)
api.category('frontend').langs().get();

// backend   — runs on a server runtime (Python, Go, Ruby, PHP, Java, C#…)
api.category('backend').langs().locale('es').get();

// fullstack — targets both browser and server (JavaScript, TypeScript…)
api.category('fullstack').langs().get();

// systems   — low-level / native / embedded (C, C++, Rust, Zig…)
api.category('systems').langs().get();

// data-science — data, ML, scientific computing (R, Julia, Python…)
api.category('data-science').langs().locale('pt').get();

// scripting — shell and scripting languages (Bash, Zsh, PowerShell…)
api.category('scripting').langs().get();

// other     — everything that does not match any of the above
api.category('other').langs().get();

// async load and locale chaining work the same as other collection methods
await api.category('backend').langs().locale('pt').load();

// list all available categories
getCategories();
// → ['frontend', 'backend', 'fullstack', 'systems', 'data-science', 'scripting', 'other']

Categories are inferred from each language's tooling.runtimes and tooling.ecosystems — no extra data is needed in individual language files.
frontend, backend, and fullstack are mutually exclusive; the remaining categories can overlap (Python appears in both backend and data-science).

Use api.paradigm(value) to filter languages by programming paradigm:

import { api, getParadigms } from "code-languages";

// Get paradigm metadata
const info = api.paradigm('functional').info();
// {
//   slug: 'functional',
//   name: 'Functional',
//   description: 'Computation through function evaluation, immutability, and avoiding side effects.',
//   aliases: ['functional', 'fp', 'pure-functional'],
// }

// Get languages that belong to this paradigm
const langs = api.paradigm('functional').langs().get();
const langsEs = api.paradigm('oop').langs().locale('es').get();
await api.paradigm('object-oriented').langs().load();

// Returns undefined / [] for unknown values
api.paradigm('unknown-xyz').info();         // undefined
api.paradigm('unknown-xyz').langs().get();  // []

// List all available paradigms
getParadigms();

Supported paradigm aliases include: functional / fp, object-oriented / oop, imperative / procedural, declarative, logic, concurrent, reactive, scripting / shell, query, markup, templating, array, systems / low-level, stack-based / concatenative, shader / gpu, and more. Searches paradigms on each language.

Use api.ecosystem(value) to filter languages by technology ecosystem:

import { api, getEcosystems } from "code-languages";

// Get ecosystem metadata
const info = api.ecosystem('jvm').info();
// {
//   slug: 'jvm',
//   name: 'JVM',
//   description: 'Languages that run on the Java Virtual Machine.',
//   aliases: ['jvm', 'java'],
// }

// Get languages that belong to this ecosystem
const langs = api.ecosystem('jvm').langs().get();
const langsEs = api.ecosystem('data-science').langs().locale('es').get();
await api.ecosystem('web').langs().load();

// Returns undefined / [] for unknown values
api.ecosystem('unknown-xyz').info();         // undefined
api.ecosystem('unknown-xyz').langs().get();  // []

// List all available ecosystems
getEcosystems();

Supported ecosystem aliases include: web / frontend, node / nodejs, jvm / java, dotnet / .net, data-science / ml, embedded / iot, game-dev / games, blockchain / web3, mobile, wasm, cloud, kubernetes / k8s, systems, formal-methods / verification, gpu / graphics, and more. Searches tooling.ecosystems on each language.

Use localizeLanguage to read localized display content with English fallback:

import { json } from "code-languages/json";
import { localizeLanguage } from "code-languages/i18n";

const language = localizeLanguage(json, "es-PE");

console.log(language.name);
console.log(language.longDescription);
console.log(language.resolvedLocale); // "es"

localizeLanguage resolves locales in this order:

1. Exact locale, for example es.
2. Base language from a regional locale, for example es-PE -> es.
3. English fallback, for example ja-JP -> en.

English, Spanish, Italian, French, German, and Portuguese are supported base locales. The current Italian, French, German, and Portuguese translations were initially generated with translategemma:4b; translation reviews and corrections are welcome.

Use detectLanguage or detectLanguages to infer languages from filenames:

import { detectLanguage, detectLanguages } from "code-languages/detect";

console.log(detectLanguage("src/index.ts")?.slug); // "typescript"
console.log(detectLanguage("Dockerfile")?.slug); // "dockerfile"
console.log(detectLanguages("include/config.h").map((language) => language.slug)); // ["c", "cpp"]

Use detectLanguageSlug or detectLanguageSlugs when you only need the slug and want to avoid importing the full language catalog:

import { detectLanguageSlug, detectLanguageSlugs } from "code-languages/detect-slugs";

console.log(detectLanguageSlug("src/index.ts")); // "typescript"
console.log(detectLanguageSlugs("include/config.h")); // ["c", "cpp"]

Use detectProjectLanguages to summarize a project file list by detected language:

import { detectProjectLanguages } from "code-languages/detect-slugs";

const files = ["src/index.ts", "src/app.ts", "README.md", "styles/main.css", "LICENSE"];

console.log(detectProjectLanguages(files));
// [
//   { slug: "typescript", files: 2 },
//   { slug: "css", files: 1 },
//   { slug: "markdown", files: 1 }
// ]

Use api.extension(value) to list every language that registers an extension or exact filename:

import { api } from "code-languages/api";

api.extension(".h").langs().get().map((language) => language.slug); // ["c", "cpp"]
api.extension("ts").langs().locale("es").get(); // leading dot optional
api.extension("Dockerfile").langs().get(); // exact filename entries work too
await api.extension(".vue").langs().load();

Use detectLanguageByShebang or detectLanguageSlugByShebang to detect extensionless scripts from their first line:

import { detectLanguageByShebang } from "code-languages/detect";
import { detectLanguageSlugByShebang } from "code-languages/detect-slugs";

detectLanguageSlugByShebang("#!/bin/bash\necho hi"); // "bash"
detectLanguageSlugByShebang("#!/usr/bin/env python3\nprint(1)"); // "python"
detectLanguageSlugByShebang("#!/usr/bin/env -S deno run --allow-net"); // "typescript"
detectLanguageByShebang("#!/usr/bin/env node\nconsole.log(1)")?.slug; // "javascript"

Shebang detection handles direct interpreter paths, env indirection with flags, and versioned interpreters such as python3.12 or perl5.36.

Use api.search(query) for ranked lookup across names, slugs, and aliases:

import { api } from "code-languages/api";

api.search("type").get().map((language) => language.slug); // ["typescript", ...]
api.search("golang").get().at(0)?.slug; // "go" — exact alias match ranks first
api.search("script").locale("es").get(); // ranked + localized

Use api.status(value) to filter by lifecycle status (active, experimental, legacy, historical; languages without a status count as active):

import { api, getStatuses } from "code-languages";

api.status("legacy").langs().get(); // VBScript, ActionScript, ...
api.status("experimental").langs().locale("es").get();
getStatuses(); // ["active", "experimental", "legacy", "historical"]

Use api.related(slug) to walk the relations graph in both directions:

import { api } from "code-languages/api";

api.related("javascript").langs().get(); // TypeScript, CoffeeScript, Elm, ...
api.related("typescript").langs().get(); // JavaScript
api.related("sql").langs().get(); // T-SQL, PL/SQL, PL/pgSQL, PRQL

Supported Languages

The catalog currently includes 313 language entries. Each row can be imported directly from its package subpath.

| Logo | Language | Slug | Extensions | Version | Import | |---|---|---|---|---|---| | | ABAP | abap | .abap | ABAP Platform 2025 FPS01 | code-languages/abap | | | ActionScript | actionscript | .as | 3.0 | code-languages/actionscript | | | Ada | ada | .adb, .ads, .ada | Ada 2022 | code-languages/ada | | | Agda | agda | .agda, .lagda, .lagda.md, .lagda.rst, .lagda.tex | 2.8.0 | code-languages/agda | | | ALGOL | algol | .alg, .algol | ALGOL 68 | code-languages/algol | | | Alloy | alloy | .als | Alloy 6 | code-languages/alloy | | | AMPL | ampl | .mod, .dat, .run | stable | code-languages/ampl | | | AngelScript | angelscript | .as, .angelscript | 2.36.1 | code-languages/angelscript | | | Ante | ante | .ante | experimental | code-languages/ante | | | ANTLR Grammar | antlr | .g4 | 4.13.2 | code-languages/antlr | | | Apex | apex | .cls, .trigger | API 66.0 | code-languages/apex | | | APL | apl | .apl, .dyalog | ISO/IEC 13751:2001 | code-languages/apl | | | AppleScript | applescript | .applescript, .scpt, .scptd | 2.8 | code-languages/applescript | | | AQL | aql | .aql | ArangoDB AQL | code-languages/aql | | | Arduino Sketch | arduino | .ino, .pde | Arduino API 1.0 | code-languages/arduino | | | AsciiDoc | asciidoc | .adoc, .asciidoc, .asc | pre-spec | code-languages/asciidoc | | | ASP/ASPX | asp | .asp, .aspx, .ascx, .ashx, .asmx, .master | 4.8.1 | code-languages/asp | | | Assembly | assembly | .asm, .s, .S, .inc | Architecture-specific | code-languages/assembly | | | AssemblyScript | assemblyscript | .as | 0.28.19 | code-languages/assemblyscript | | | Astro | astro | .astro | 7.0.9 | code-languages/astro | | | Austral | austral | .aum, .aui | 0.1.0 | code-languages/austral | | | AutoHotkey | autohotkey | .ahk, .ah2 | 2.0 | code-languages/autohotkey | | | Avro IDL | avro-idl | .avdl | 1.12.1 | code-languages/avro-idl | | | awk | awk | .awk | GNU Awk 5.4.1 | code-languages/awk | | | Ballerina | ballerina | .bal | 2201.12.0 | code-languages/ballerina | | | Bash | bash | .sh, .bash, .bashrc, .bash_profile, .bash_login, .profile | 5.3 | code-languages/bash | | | BASIC | basic | .bas, .bi, .bb | FreeBASIC 1.10.1 | code-languages/basic | | | Batch | batch | .bat, .cmd | Windows Command Processor | code-languages/batch | | | Bazel | bazel | BUILD.bazel, WORKSPACE, WORKSPACE.bazel, MODULE.bazel | 9.2.0 | code-languages/bazel | | | BCPL | bcpl | .bcpl | Cintsys BCPL | code-languages/bcpl | | | BibTeX | bibtex | .bib, .bibtex | stable | code-languages/bibtex | | | Bicep | bicep | .bicep, .bicepparam | 0.45.15 | code-languages/bicep | | | Blade | blade | .blade.php | Laravel 12.x | code-languages/blade | | | Bosque | bosque | .bsq | experimental | code-languages/bosque | | | BQN | bqn | .bqn | BQN specification | code-languages/bqn | | | Brainfuck | brainfuck | .bf, .b | stable | code-languages/brainfuck | | | C | c | .c, .h | C23 | code-languages/c | | | C3 | c3 | .c3, .c3i | 0.7.5 | code-languages/c3 | | | Cairo | cairo | .cairo | 2.19.0 | code-languages/cairo | | | Cap'n Proto | capnproto | .capnp | stable | code-languages/capnproto | | | Carbon | carbon | .carbon | 0.0.0 nightly | code-languages/carbon | | | Common Expression Language | cel | .cel | 0.25.2 | code-languages/cel | | | Chapel | chapel | .chpl | 2.9.0 | code-languages/chapel | | | Circom | circom | .circom | 2.2.3 | code-languages/circom | | | Clarity | clarity | .clar | Clarity 3 | code-languages/clarity | | | Clojure | clojure | .clj, .cljs, .cljc, .edn, .bb | 1.12.5 | code-languages/clojure | | | CMake | cmake | CMakeLists.txt, .cmake | 4.4.0 | code-languages/cmake | | | COBOL | cobol | .cob, .cbl, .cobol, .cpy | ISO/IEC 1989:2023 | code-languages/cobol | | | CoffeeScript | coffeescript | .coffee, .litcoffee, .cson | 2.7.0 | code-languages/coffeescript | | | ColdFusion | coldfusion | .cfm, .cfml, .cfc | ColdFusion 2025 | code-languages/coldfusion | | | Coq / Rocq | coq | .v | 9.2.0 | code-languages/coq | | | C++ | cpp | .cpp, .cc, .cxx, .h, .hpp, .hh, .hxx | C++23 | code-languages/cpp | | | CQL | cql | .cql | CQL 3 | code-languages/cql | | | Crystal | crystal | .cr | 1.20.3 | code-languages/crystal | | | C# | csharp | .cs, .csx | 14 | code-languages/csharp | | | CSS | css | .css | Living Standard | code-languages/css | | | CUDA | cuda | .cu, .cuh | 13.3.1 | code-languages/cuda | | | CUE | cue | .cue | 0.17.0 | code-languages/cue | | | Curry | curry | .curry, .lcurry | Curry 0.9.0 | code-languages/curry | | | Common Workflow Language | cwl | .cwl | v1.2 | code-languages/cwl | | | Cypher | cypher | .cypher, .cyp | 25 | code-languages/cypher | | | Cython | cython | .pyx, .pxd, .pxi | 3.2.8 | code-languages/cython | | | D | d | .d, .di | 2.112.0 | code-languages/d | | | Dafny | dafny | .dfy | 4.11.0 | code-languages/dafny | | | Dart | dart | .dart | 3.12.2 | code-languages/dart | | | DAX | dax | .dax | DAX 2025 | code-languages/dax | | | Dhall | dhall | .dhall | 23.1.0 | code-languages/dhall | | | DITA | dita | .dita, .ditamap, .ditaval | 1.3 | code-languages/dita | | | Dockerfile | dockerfile | Dockerfile, .dockerfile | 1.10 | code-languages/dockerfile | | | DOT | dot | .dot, .gv | stable | code-languages/dot | | | Earthly | earthly | Earthfile | 0.8.16 | code-languages/earthly | | | EdgeQL | edgeql | .edgeql | Gel 6 | code-languages/edgeql | | | EditorConfig | editorconfig | .editorconfig | stable | code-languages/editorconfig | | | Eiffel | eiffel | .e | 24.05 | code-languages/eiffel | | | EJS | ejs | .ejs | 3.1.10 | code-languages/ejs | | | Elixir | elixir | .ex, .exs, .eex, .leex, .heex | 1.20.2 | code-languages/elixir | | | Elm | elm | .elm | 0.19.2 | code-languages/elm | | | Emacs Lisp | emacs-lisp | .el | Emacs 30.1 | code-languages/emacs-lisp | | | ERB | erb | .erb, .rhtml, .html.erb | Ruby stdlib | code-languages/erb | | | Erlang | erlang | .erl, .hrl, .app.src, .escript, .xrl, .yrl, rebar.config | OTP 29.0.3 | code-languages/erlang | | | Factor | factor | .factor | 0.101 | code-languages/factor | | | Faust | faust | .dsp | stable | code-languages/faust | | | Fe | fe | .fe | experimental | code-languages/fe | | | Fennel | fennel | .fnl | 1.6.1 | code-languages/fennel | | | Fish | fish | .fish | 4.8.1 | code-languages/fish | | | FlatBuffers | flatbuffers | .fbs | 25.12.19 | code-languages/flatbuffers | | | Flix | flix | .flix | 0.60.0 | code-languages/flix | | | Flux | flux | .flux | 0.200.0 | code-languages/flux | | | Forth | forth | .fs, .fth, .forth, .4th | Forth 2012 | code-languages/forth | | | Fortran | fortran | .f, .for, .ftn, .f90, .f95, .f03, .f08, .f18, .f23 | Fortran 2023 | code-languages/fortran | | | FQL | fql | .fql | legacy | code-languages/fql | | | FreeMarker | freemarker | .ftl, .ftlh, .ftlx | 2.3.34 | code-languages/freemarker | | | F# | fsharp | .fs, .fsi, .fsx, .fsscript | 10 | code-languages/fsharp | | | F* | fstar | .fst, .fsti | 2026.04.17 | code-languages/fstar | | | Futhark | futhark | .fut | 0.25.32 | code-languages/futhark | | | G-code | gcode | .gcode, .gco, .nc, .cnc, .tap | RS-274 | code-languages/gcode | | | GDScript | gdscript | .gd | 4.7 | code-languages/gdscript | | | Gettext | gettext | .po, .pot | stable | code-languages/gettext | | | Git | git | .git, .gitignore, .gitattributes, .gitmodules, .gitkeep | 2.55.0 | code-languages/git | | | Gleam | gleam | .gleam | 1.17.0 | code-languages/gleam | | | GLSL | glsl | .glsl, .vert, .frag, .geom, .tesc, .tese, .comp, .vs, .fs | 4.60 | code-languages/glsl | | | GML | gml | .gml | 2024.13.0 | code-languages/gml | | | Go | go | .go | 1.26.5 | code-languages/go | | | Gradle | gradle | .gradle, .gradle.kts | 9.6.1 | code-languages/gradle | | | Grain | grain | .gr | grain-v0.7.2 | code-languages/grain | | | GraphQL | graphql | .graphql, .gql, .graphqls | September 2025 | code-languages/graphql | | | Gremlin | gremlin | .gremlin, .grem | stable | code-languages/gremlin | | | Groovy | groovy | .groovy, .gvy, .gy, .gsh | 5.0.7 | code-languages/groovy | | | Hack | hack | .hack, .hh, .hhi | HHVM 4.x | code-languages/hack | | | Haml | haml | .haml | 7.2.0 | code-languages/haml | | | Handlebars | handlebars | .hbs, .handlebars | 4.7.9 | code-languages/handlebars | | | Hare | hare | .ha | 0.25.1 | code-languages/hare | | | Haskell | haskell | .hs, .lhs, .hsc, .hs-boot, .hsig, .cabal | GHC 9.14.1 | code-languages/haskell | | | Haxe | haxe | .hx, .hxml | 4.3.7 | code-languages/haxe | | | HCL | hcl | .hcl, .tf, .tfvars, .pkr.hcl, .nomad | 2.24.0 | code-languages/hcl | | | HLSL | hlsl | .hlsl, .fx, .fxh, .hlsli | Shader Model 6.9 | code-languages/hlsl | | | HOCON | hocon | .hocon | 1.4.3 | code-languages/hocon | | | HTML | html | .html, .htm | Living Standard | code-languages/html | | | Hy | hy | .hy | 1.0.0 | code-languages/hy | | | Idris | idris | .idr, .lidr, .ipkg | 0.8.0 | code-languages/idris | | | INI | ini | .ini | Informal format | code-languages/ini | | | Ink! | ink | .ink | Ink! 6 | code-languages/ink | | | Ink | ink-narrative | .ink | 1.2.0 | code-languages/ink-narrative | | | Io | io | .io | 2017.09.06 | code-languages/io | | | Isabelle | isabelle | .thy | Isabelle2025-2 | code-languages/isabelle | | | J | j | .ijs | J9.6 | code-languages/j | | | Janet | janet | .janet, .jdn | 1.41.2 | code-languages/janet | | | Java | java | .java | 26 | code-languages/java | | | JavaScript | javascript | .js, .mjs, .cjs, .jsx | ECMAScript 2025 | code-languages/javascript | | | JCL | jcl | .jcl | z/OS 3.1 | code-languages/jcl | | | Jinja | jinja | .jinja, .jinja2, .j2 | 3.1.6 | code-languages/jinja | | | JMESPath | jmespath | .jmespath, .jp | stable | code-languages/jmespath | | | jq | jq | .jq | 1.8.1 | code-languages/jq | | | JSON | json | .json | RFC 8259 | code-languages/json | | | JSON5 | json5 | .json5 | 2.2.3 | code-languages/json5 | | | JSONata | jsonata | .jsonata | stable | code-languages/jsonata | | | JSONC | jsonc | .jsonc, .code-workspace | JSON with Comments | code-languages/jsonc | | | Jsonnet | jsonnet | .jsonnet, .libsonnet | 0.22.0 | code-languages/jsonnet | | | Julia | julia | .jl | 1.12.6 | code-languages/julia | | | Jupyter Notebook | jupyter-notebook | .ipynb | nbformat 4.5 | code-languages/jupyter-notebook | | | Just | just | justfile, Justfile, .just | 1.55.1 | code-languages/just | | | KCL | kcl | .k, .kcl | 0.11.2 | code-languages/kcl | | | KDL | kdl | .kdl | 2.0.0 | code-languages/kdl | | | Koka | koka | .kk | 3.2.2 | code-languages/koka | | | Kotlin | kotlin | .kt, .kts | 2.4.10 | code-languages/kotlin | | | KQL | kql | .kql | stable | code-languages/kql | | | Lean | lean | .lean | 4.32.0 | code-languages/lean | | | Less | less | .less | 4.6.7 | code-languages/less | | | Lex | lex | .l, .lex | POSIX lex / flex 2.6.4 | code-languages/lex | | | Ligo | ligo | .ligo, .mligo, .religo, .jsligo | 1.x | code-languages/ligo | | | Linker Script | linkerscript | .ld, .lds, .x | stable | code-languages/linkerscript | | | Liquid | liquid | .liquid | 10.27.2 | code-languages/liquid | | | Lisp | lisp | .lisp, .lsp, .cl, .asd | ANSI INCITS 226-1994 | code-languages/lisp | | | LLVM IR | llvm-ir | .ll, .bc | 22.1.8 | code-languages/llvm-ir | | | Lobster | lobster | .lobster | development snapshot | code-languages/lobster | | | Logo | logo | .logo, .lgo | UCBLogo 6.2 | code-languages/logo | | | Lua | lua | .lua, .rockspec | 5.5.0 | code-languages/lua | | | Luau | luau | .luau | 0.729 | code-languages/luau | | | Makefile | makefile | Makefile, makefile, GNUmakefile, .mk, .mak | 4.4.1 | code-languages/makefile | | | Mako | mako | .mako, .mao | 1.3.10 | code-languages/mako | | | Markdown | markdown | .md, .markdown, .mdown, .mkd | CommonMark 4.0 | code-languages/markdown | | | Marlowe | marlowe | .marlowe | Marlowe Runtime | code-languages/marlowe | | | Wolfram Language | mathematica | .wl, .wls, .nb | 14.3 | code-languages/mathematica | | | MATLAB | matlab | .m, .mlx | R2026a | code-languages/matlab | | | Maxima | maxima | .mac, .wxm | 5.49.0 | code-languages/maxima | | | MDX | mdx | .mdx | 3.1.1 | code-languages/mdx | | | Mercury | mercury | .m | 22.01.8 | code-languages/mercury | | | Mermaid | mermaid | .mmd, .mermaid | 11.16.0 | code-languages/mermaid | | | Meson | meson | meson.build, meson_options.txt, meson.options, .wrap | 1.11.2 | code-languages/meson | | | Metal | metal | .metal | Metal 4 | code-languages/metal | | | Modelica | modelica | .mo | 3.6.1 | code-languages/modelica | | | Modula-2 | modula-2 | .mod, .def | ISO/IEC 10514-1:1996 | code-languages/modula-2 | | | Mojo | mojo | .mojo | 0.26.1 | code-languages/mojo | | | MoonBit | moonbit | .mbt | 0.9.2 | code-languages/moonbit | | | Move | move | .move | 2.0.0 | code-languages/move | | | MUMPS | mumps | .mac, .int, .ro, .mro | InterSystems IRIS 2025.1 | code-languages/mumps | | | Mustache | mustache | .mustache, .mst | 1.0 | code-languages/mustache | | | N1QL | n1ql | .n1ql | stable | code-languages/n1ql | | | Nextflow | nextflow | .nf | 26.04.4 | code-languages/nextflow | | | nginx | nginx | nginx.conf, .nginx, .conf | 1.30.4 | code-languages/nginx | | | Nickel | nickel | .ncl | 1.17.0 | code-languages/nickel | | | Nim | nim | .nim, .nims, .nimble | 2.2.10 | code-languages/nim | | | Nix | nix | .nix | 2.34.8 | code-languages/nix | | | Noir | noir | .nr | 1.0.0-beta | code-languages/noir | | | Nunjucks | nunjucks | .njk, .nunjucks | 3.2.4 | code-languages/nunjucks | | | Nushell | nushell | .nu | 0.114.1 | code-languages/nushell | | | Oberon | oberon | .ob, .mod | Oberon-2 | code-languages/oberon | | | Objective-C | objective-c | .m, .mm | 2.0 | code-languages/objective-c | | | OCaml | ocaml | .ml, .mli, .mll, .mly, .mlt, .eliom, .eliomi | 5.6.0 | code-languages/ocaml | | | Octave | octave | .m, .octave | 9.3.0 | code-languages/octave | | | Odin | odin | .odin | dev-2026-02 | code-languages/odin | | | OpenAPI | openapi | .openapi.json, .openapi.yaml, .openapi.yml | 3.2.0 | code-languages/openapi | | | OpenCL C | opencl | .cl, .clh | OpenCL C 3.0 | code-languages/opencl | | | OpenSCAD | openscad | .scad | 2021.01 | code-languages/openscad | | | Org-mode | org | .org | 9.8 | code-languages/org | | | Pascal | pascal | .pas, .pp, .inc, .lpr, .dpr, .dfm | 3.2.2 | code-languages/pascal | | | Perl | perl | .pl, .pm, .pod, .t, .psgi | 5.42.2 | code-languages/perl | | | PHP | php | .php, .phtml, .php3, .php4, .php5, .phps | 8.5.8 | code-languages/php | | | Pine Script | pine-script | .pine | v6 | code-languages/pine-script | | | Pkl | pkl | .pkl | 0.31.1 | code-languages/pkl | | | PL/I | pl-i | .pli, .pl1 | Enterprise PL/I 6.2 | code-languages/pl-i | | | PlantUML | plantuml | .puml, .plantuml, .iuml | 1.2026.6 | code-languages/plantuml | | | PL/pgSQL | plpgsql | .pgsql, .plpgsql | stable | code-languages/plpgsql | | | Oracle PL/SQL | plsql | .pls, .pks, .pkb, .plsql | Oracle Database 26ai | code-languages/plsql | | | Plain Old Documentation | pod | .pod | Perl 5.42.2 | code-languages/pod | | | Pony | pony | .pony | 0.61.1 | code-languages/pony | | | PostScript | postscript | .ps, .eps | PostScript 3 | code-languages/postscript | | | Power Query M | powerquery | .pq, .pqm | Power Query M 2025 | code-languages/powerquery | | | PowerShell | powershell | .ps1, .psm1, .psd1, .ps1xml | 7.6.3 | code-languages/powershell | | | Processing | processing | .pde | 4.4.5 | code-languages/processing | | | Prolog | prolog | .pl, .pro, .prolog, .P | SWI-Prolog 10.0 | code-languages/prolog | | | PromQL | promql | .promql | Prometheus 3.x | code-languages/promql | | | Java Properties | properties | .properties | stable | code-languages/properties | | | Protocol Buffers | protobuf | .proto | 35.1 | code-languages/protobuf | | | PRQL | prql | .prql | 0.13.0 | code-languages/prql | | | Pug | pug | .pug, .jade | 3.0.4 | code-languages/pug | | | Puppet | puppet | .pp, .epp | Puppet 8 | code-languages/puppet | | | PureScript | purescript | .purs | 0.15.16 | code-languages/purescript | | | Python | python | .py, .pyw | 3.14.6 | code-languages/python | | | q / kdb+ | q | .q, .k | q 4.1 | code-languages/q | | | qmake | qmake | .pri, .prf | stable | code-languages/qmake | | | QML | qml | .qml, .qmltypes, .qmlproject | Qt 6.11.1 | code-languages/qml | | | Q# | qsharp | .qs | Q# 1.0 | code-languages/qsharp | | | R | r | .r, .R, .rmd, .Rmd, .qmd, .Rprofile | 4.6.1 | code-languages/r | | | Racket | racket | .rkt, .rktd, .rktl, .scrbl | 9.2 | code-languages/racket | | | Raku | raku | .raku, .rakumod, .rakudoc, .rakutest, .p6, .pm6 | 6.d | code-languages/raku | | | Razor | razor | .cshtml, .razor | 10.0.10 | code-languages/razor | | | ReasonML | reasonml | .re, .rei | 3.13.0 | code-languages/reasonml | | | Rebol | rebol | .r, .reb, .rebol | Rebol 3 | code-languages/rebol | | | Red | red | .red, .reds | 0.6.6 | code-languages/red | | | Rego | rego | .rego | OPA 1.18.2 | code-languages/rego | | | Ren'Py | renpy | .rpy, .rpym | 8.3.7 | code-languages/renpy | | | ReScript | rescript | .res, .resi | 12.3.0 | code-languages/rescript | | | reStructuredText | restructuredtext | .rst, .rest | Docutils 0.22.2 | code-languages/restructuredtext | | | REXX | rexx | .rexx, .rex | ANSI X3.274-1996 | code-languages/rexx | | | Roc | roc | .roc | development snapshot | code-languages/roc | | | RPG | rpg | .rpg, .rpgle, .sqlrpgle, .clle, .dspf | RPG IV Free-Form (IBM i 7.5) | code-languages/rpg | | | Ruby | ruby | .rb, .rbw, .rake, .gemspec, Gemfile, Rakefile, config.ru | 4.0.6 | code-languages/ruby | | | Rust | rust | .rs | 1.97.0 | code-languages/rust | | | SAS | sas | .sas | SAS 9.4 | code-languages/sas | | | Scala | scala | .scala, .sc | 3.8.4 | code-languages/scala | | | Scheme | scheme | .scm, .ss, .sld, .sls | R7RS small | code-languages/scheme | | | Sass | scss | .scss, .sass | 1.101.0 | code-languages/scss | | | Self | self | .self | 2024.1 | code-languages/self | | | Simula | simula | .sim, .simula | Simula 67 | code-languages/simula | | | Slang | slang | .slang | stable | code-languages/slang | | | Smalltalk | smalltalk | .st | ANSI INCITS 319-1998 | code-languages/smalltalk | | | Smarty | smarty | .tpl, .smarty | 5.5.1 | code-languages/smarty | | | Smithy | smithy | .smithy | IDL 2.0 | code-languages/smithy | | | Snakemake | snakemake | .smk, Snakefile | 9.23.1 | code-languages/snakemake | | | SNOBOL | snobol | .sno, .snobol | SNOBOL4 | code-languages/snobol | | | Solidity | solidity | .sol | 0.8.36 | code-languages/solidity | | | SOQL | soql | .soql | stable | code-languages/soql | | | SPARK | spark | .spark, .adb, .ads | SPARK Community 2021 | code-languages/spark | | | SPARQL | sparql | .sparql, .rq | 1.1 | code-languages/sparql | | | SPL | spl | .spl | stable | code-languages/spl | | | SPSS | spss | .sps, .spss | 29.0 | code-languages/spss | | | SQL | sql | .sql | SQL:2023 | code-languages/sql | | <