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

Filters compose. Every language collection is chainable: call .category(), .paradigm(), .runtime(), .packageManager(), .ecosystem(), .extension(), .status(), or .related() on any langs(), languages(), search(), or detectAll() result to intersect filters. Order does not matter, and .locale() can be set at any point in the chain:

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

// Backend languages that are also functional
api.category("backend").langs().paradigm("functional").get(); // Elixir, Erlang, ...

// Active languages that run on Node.js, localized
api.languages().runtime("node").status("active").locale("es").get();

// Systems languages registering the .h extension
api.category("systems").langs().extension(".h").get(); // C, C++

// Ranked search narrowed by lifecycle status
api.search("script").status("active").get();

Collections also offer cheap helpers that skip localization: .slugs() returns the matching catalog slugs, .count() the number of matches, and .first() the first match localized (or undefined when the collection is empty):

api.category("backend").langs().paradigm("functional").slugs(); // ["clojure", "elixir", ...]
api.runtime("node").langs().count(); // number of matching languages
api.search("golang").first()?.slug; // "go"

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.1.3	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.21.0	code-languages/crystal
	C#	csharp	.cs, .csx	14	code-languages/csharp
	CSS	css	.css	Living Standard	code-languages/css
	CUDA	cuda	.cu, .cuh	13.4.0	code-languages/cuda
	CUE	cue	.cue	0.17.1	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.7.0	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.730	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.35.2	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.44.0	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.44.0	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.4	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.1	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.3	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
	Squirrel	squirrel	.nut	3.2	code-languages/squirrel
	Standard ML	standard-ml	.sml, .sig, .fun	The Definition 1997	code-languages/standard-ml
	Starlark	starlark	.bzl, .star, .sky	Bazel Starlark	code-languages/starlark
	Stata	stata	.do, .ado, .mata	19	code-languages/stata
	Stylus	stylus	.styl	0.64.0	code-languages/stylus
	SuperCollider	supercollider	.scd, .sc	3.13.0	code-languages/supercollider
	Svelte	svelte	.svelte	5.56.7	code-languages/svelte
	SVG	svg	.svg, .svgz	SVG 2	code-languages/svg
	SVN	svn	.svn, svnserve.conf	1.14.5	code-languages/svn
	Sway	sway	.sw	0.69.0	code-languages/sway
	Swift	swift	.swift	6.3.3	code-languages/swift
	Tcl/Tk	tcl	.tcl, .tm, .test	9.0.4	code-languages/tcl
	Tcsh	tcsh	.tcsh, .csh, .tcshrc, .cshrc	6.24.16	code-languages/tcsh
	TeX	tex	.tex, .sty, .cls, .dtx, .ins, .ltx	TeX Live 2026	code-languages/tex
	Textile	textile	.textile	4.1.4	code-languages/textile
	Apache Thrift	thrift	.thrift	0.23.0	code-languages/thrift
	TLA+	tla-plus	.tla	TLA+ 2	code-languages/tla-plus
	TOML	toml	.toml	1.1.0	code-languages/toml
	Troff/Groff	troff	.roff, .troff, .man, .me, .ms	GNU groff 1.24.1	code-languages/troff
	T-SQL	tsql	.sql, .tsql	SQL Server 2025 (17.x)	code-languages/tsql
	Twee/Twine	twee	.tw, .twee, .tw2	2.10.0	code-languages/twee
	Twig	twig	.twig	3.28.0	code-languages/twig
	TypeScript	typescript	.ts, .tsx, .mts, .cts	7.0	code-languages/typescript
	TypeSpec	typespec	.tsp	1.0	code-languages/typespec
	Typst	typst	.typ	0.15.1	code-languages/typst
	Unison	unison	.u, .uu	0.5.28	code-languages/unison
	V	v	.v, .vsh	weekly.2025.49	code-languages/v
	Vala	vala	.vala, .vapi	0.56.18	code-languages/vala
	Vale	vale	.vale	experimental	code-languages/vale
	VBA	vba	.bas, .cls, .frm, .vba	VBA 7.1	code-languages/vba
	VBScript	vbscript	.vbs, .vbe	5.8	code-languages/vbscript
	Apache Velocity	velocity	.vm, .vtl	2.4.1	code-languages/velocity
	Verilog/SystemVerilog	verilog	.v, .vh, .sv, .svh	IEEE 1800-2023	code-languages/verilog
	Verse	verse	.verse	UEFN Verse	code-languages/verse
	VHDL	vhdl	.vhd, .vhdl	IEEE 1076-2019	code-languages/vhdl
	Vim script	vimscript	.vim, .vimrc, .gvimrc	Vim 9.1	code-languages/vimscript
	Visual Basic	visual-basic	.vb	17.13	code-languages/visual-basic
	Vue	vue	.vue	3.5.40	code-languages/vue
	Vyper	vyper	.vy	0.4.3	code-languages/vyper
	WDL	wdl	.wdl	1.2.0	code-languages/wdl
	WebAssembly	webassembly	.wasm, .wat	3.0	code-languages/webassembly
	WGSL	wgsl	.wgsl	Candidate Recommendation Draft 2026-05-07	code-languages/wgsl
	Wren	wren	.wren	0.4.0	code-languages/wren
	XAML	xaml	.xaml, .baml	Platform-specific	code-languages/xaml
	XML	xml	.xml, .xsd, .xsl, .xslt	XML 1.0 Fifth Edition	code-languages/xml
	XPath	xpath	.xpath, .xpth	XPath 3.1	code-languages/xpath
	XQuery	xquery	.xq, .xql, .xqm, .xquery, .xqy	XQuery 3.1	code-languages/xquery
	XSLT	xslt	.xsl, .xslt	XSLT 3.0	code-languages/xslt
	Yacc	yacc	.y, .yacc	POSIX yacc / Bison 3.8.2	code-languages/yacc
	YAML	yaml	.yaml, .yml	1.2.2	code-languages/yaml
	YARA	yara	.yar, .yara	4.5.5	code-languages/yara
	Zeek	zeek	.zeek, .bro	8.0.8	code-languages/zeek
	Zig	zig	.zig, .zon	0.16.0	code-languages/zig
	Ziggy	ziggy	.ziggy, .ziggy-schema	0.1.0	code-languages/ziggy
	zsh	zsh	.zsh, .zshrc, .zshenv, .zprofile, .zlogin, .zlogout, .zsh-theme	5.9.2	code-languages/zsh

Development

npm ci
npm run check
npm run build

Common scripts:

Script	Purpose
npm run format	Format and auto-fix with Biome
npm run format:check	Check formatting with Biome (read-only)
npm run lint	Run ESLint
npm run lint:fix	Run ESLint with auto-fix
npm run typecheck	Run TypeScript without emitting files
npm test	Run Vitest
npm run bench	Run manual performance benchmarks
npm run build	Build ESM, CommonJS, and declaration files
npm run check	Run format:check, lint, typecheck, and tests
npm run check:language-versions -- --language typescript	Check release metadata for one language
npm run website:prepare	Build the static website data, unit test summary, and benchmark summary
npm run website:serve	Preview the static website locally

Website

The static website lives in docs and is generated from the package build. It includes a live filename detector, localized language lookup, the full language catalog, unit test summary, and benchmark summary.

npm run website:prepare
npm run website:serve

Contributing

See CONTRIBUTING.md for setup instructions, field rules, and the process for adding a new language.

License

MIT