code-languages 1.40.11 → 1.42.0

package/dist/detect.js

@@ -1,3 +1,127 @@
+// src/domain/detection/match.ts
+var pathSegmentPattern = /[/\\]/;
+var indexCache = /* @__PURE__ */ new WeakMap();
+var getBasename = (filename) => {
+  const parts = filename.trim().split(pathSegmentPattern);
+  return parts.at(-1).toLowerCase();
+};
+var addIndexKey = (index, key, match) => {
+  const matches = index.get(key);
+  if (matches) {
+    matches.push(match);
+  } else {
+    index.set(key, [match]);
+  }
+};
+var buildDetectionIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  entries.forEach((entry, entryIndex) => {
+    for (const extension of entry.extensions) {
+      const normalizedExtension = extension.toLowerCase();
+      const match = { entry, index: entryIndex, matchLength: extension.length };
+      if (normalizedExtension.startsWith(".")) {
+        addIndexKey(index, normalizedExtension, match);
+      } else {
+        addIndexKey(index, normalizedExtension, match);
+        addIndexKey(index, `.${normalizedExtension}`, match);
+      }
+    }
+  });
+  return index;
+};
+var getDetectionIndex = (entries) => {
+  let index = indexCache.get(entries);
+  if (!index) {
+    index = buildDetectionIndex(entries);
+    indexCache.set(entries, index);
+  }
+  return index;
+};
+var getLookupKeys = (basename) => {
+  const keys = [basename];
+  for (let position = basename.indexOf("."); position !== -1; position = basename.indexOf(".", position + 1)) {
+    const suffix = basename.slice(position);
+    if (suffix !== basename) {
+      keys.push(suffix);
+    }
+  }
+  return keys;
+};
+var detectMatchingEntries = (entries, filename) => {
+  const basename = getBasename(filename);
+  if (!basename) {
+    return [];
+  }
+  const index = getDetectionIndex(entries);
+  const bestMatches = /* @__PURE__ */ new Map();
+  for (const key of getLookupKeys(basename)) {
+    for (const match of index.get(key) ?? []) {
+      const existing = bestMatches.get(match.index);
+      if (!existing || match.matchLength > existing.matchLength) {
+        bestMatches.set(match.index, match);
+      }
+    }
+  }
+  return [...bestMatches.values()].sort((first, second) => second.matchLength - first.matchLength || first.index - second.index).map(({ entry }) => entry);
+};
+
+// src/domain/detection/shebang.ts
+var SHEBANG_INTERPRETERS = {
+  awk: "awk",
+  bash: "bash",
+  bun: "javascript",
+  crystal: "crystal",
+  csh: "tcsh",
+  dash: "bash",
+  deno: "typescript",
+  elixir: "elixir",
+  escript: "erlang",
+  expect: "tcl",
+  fish: "fish",
+  gawk: "awk",
+  groovy: "groovy",
+  guile: "scheme",
+  janet: "janet",
+  julia: "julia",
+  ksh: "bash",
+  lua: "lua",
+  mawk: "awk",
+  nawk: "awk",
+  node: "javascript",
+  nodejs: "javascript",
+  nu: "nushell",
+  osascript: "applescript",
+  perl: "perl",
+  php: "php",
+  pwsh: "powershell",
+  python: "python",
+  racket: "racket",
+  raku: "raku",
+  rscript: "r",
+  ruby: "ruby",
+  scala: "scala",
+  sh: "bash",
+  tclsh: "tcl",
+  tcsh: "tcsh",
+  wish: "tcl",
+  zsh: "zsh"
+};
+var trailingVersionPattern = /[-.]?\d[\d.]*$/;
+var lookupInterpreter = (interpreter) => SHEBANG_INTERPRETERS[interpreter] ?? SHEBANG_INTERPRETERS[interpreter.replace(trailingVersionPattern, "")];
+var detectLanguageSlugByShebang = (content) => {
+  if (!content.startsWith("#!")) {
+    return void 0;
+  }
+  const newlineIndex = content.search(/\r?\n/);
+  const firstLine = newlineIndex === -1 ? content : content.slice(0, newlineIndex);
+  const parts = firstLine.slice(2).trim().split(/\s+/);
+  let interpreter = parts[0]?.split("/").at(-1)?.toLowerCase();
+  if (interpreter === "env") {
+    interpreter = parts.slice(1).find((argument) => !argument.startsWith("-"))?.split("/").at(-1)?.toLowerCase();
+  }
+  return interpreter ? lookupInterpreter(interpreter) : void 0;
+};
+
 // src/languages/abap.ts
 var abap = {
   slug: "abap",
@@ -50,10 +174,11 @@ var abap = {
 // src/languages/actionscript.ts
 var actionscript = {
   slug: "actionscript",
+  status: "legacy",
   publishedDate: "1998-01-01",
   extensions: [".as"],
   author: "Gary Grossman / Macromedia",
-  website: "https://airsdk.dev/docs/development/actionscript-3.0",
+  website: "https://airsdk.dev",
   paradigms: ["event-driven", "imperative", "object-oriented", "scripting"],
   tooling: {
     runtimes: ["Adobe Flash Player", "Adobe AIR", "Apache Royale"],
@@ -199,6 +324,7 @@ var agda = {
 // src/languages/algol.ts
 var algol = {
   slug: "algol",
+  status: "historical",
   publishedDate: "1958-01-01",
   extensions: [".alg", ".algol"],
   author: "ACM-GAMM committee",
@@ -209,7 +335,7 @@ var algol = {
     ecosystems: ["Academic Computing", "Language Design", "Numerical Computing"]
   },
   version: "ALGOL 68",
-  logo: "https://dummyimage.com/32x32/6B7280/ffffff.png&text=ALG",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/algol.svg",
   color: "#6B7280",
   i18n: {
     en: {
@@ -245,6 +371,55 @@ var algol = {
   }
 };
 
+// src/languages/alloy.ts
+var alloy = {
+  slug: "alloy",
+  publishedDate: "2002-01-01",
+  extensions: [".als"],
+  author: "Daniel Jackson / MIT",
+  website: "https://alloytools.org",
+  paradigms: ["declarative", "logic", "formal-methods"],
+  tooling: {
+    runtimes: ["Alloy Analyzer", "JVM"],
+    ecosystems: ["Formal Methods", "Verification"]
+  },
+  version: "Alloy 6",
+  logo: "https://avatars.githubusercontent.com/u/30268214?v=4",
+  color: "#64C800",
+  i18n: {
+    en: {
+      name: "Alloy",
+      description: "A relational modeling language with a SAT-based analyzer for finding design flaws.",
+      longDescription: "Alloy is a declarative modeling language based on relational logic, created by Daniel Jackson at MIT. Models describe structures and constraints; the Alloy Analyzer exhaustively searches bounded scopes with a SAT solver to find counterexamples, and Alloy 6 adds temporal operators for modeling system behavior over time.\n\nAlloy is used to check software designs, security protocols, and data models before implementation, catching subtle flaws that testing rarely reaches."
+    },
+    es: {
+      name: "Alloy",
+      description: "Un lenguaje de modelado relacional con un analizador basado en SAT para hallar fallos de dise\xF1o.",
+      longDescription: "Alloy es un lenguaje de modelado declarativo basado en l\xF3gica relacional, creado por Daniel Jackson en el MIT. Los modelos describen estructuras y restricciones; el Alloy Analyzer busca exhaustivamente en \xE1mbitos acotados con un solucionador SAT para encontrar contraejemplos, y Alloy 6 a\xF1ade operadores temporales para modelar el comportamiento del sistema en el tiempo.\n\nAlloy se usa para verificar dise\xF1os de software, protocolos de seguridad y modelos de datos antes de la implementaci\xF3n, atrapando fallos sutiles que las pruebas rara vez alcanzan."
+    },
+    it: {
+      name: "Alloy",
+      description: "Un linguaggio di modellazione relazionale con un analizzatore basato su SAT per trovare difetti di progetto.",
+      longDescription: "Alloy \xE8 un linguaggio di modellazione dichiarativo basato sulla logica relazionale, creato da Daniel Jackson al MIT. I modelli descrivono strutture e vincoli; l'Alloy Analyzer esplora esaustivamente ambiti limitati con un risolutore SAT per trovare controesempi, e Alloy 6 aggiunge operatori temporali per modellare il comportamento del sistema nel tempo.\n\nAlloy \xE8 usato per verificare progetti software, protocolli di sicurezza e modelli di dati prima dell'implementazione, catturando difetti sottili che i test raramente raggiungono."
+    },
+    fr: {
+      name: "Alloy",
+      description: "Un langage de mod\xE9lisation relationnelle avec un analyseur SAT pour d\xE9tecter les d\xE9fauts de conception.",
+      longDescription: "Alloy est un langage de mod\xE9lisation d\xE9claratif fond\xE9 sur la logique relationnelle, cr\xE9\xE9 par Daniel Jackson au MIT. Les mod\xE8les d\xE9crivent structures et contraintes ; l'Alloy Analyzer explore exhaustivement des port\xE9es born\xE9es avec un solveur SAT pour trouver des contre-exemples, et Alloy 6 ajoute des op\xE9rateurs temporels pour mod\xE9liser le comportement des syst\xE8mes dans le temps.\n\nAlloy sert \xE0 v\xE9rifier des conceptions logicielles, des protocoles de s\xE9curit\xE9 et des mod\xE8les de donn\xE9es avant l'impl\xE9mentation, d\xE9busquant des d\xE9fauts subtils que les tests atteignent rarement."
+    },
+    de: {
+      name: "Alloy",
+      description: "Eine relationale Modellierungssprache mit SAT-basiertem Analyzer zum Aufsp\xFCren von Designfehlern.",
+      longDescription: "Alloy ist eine deklarative Modellierungssprache auf Basis relationaler Logik, geschaffen von Daniel Jackson am MIT. Modelle beschreiben Strukturen und Constraints; der Alloy Analyzer durchsucht begrenzte Suchr\xE4ume ersch\xF6pfend mit einem SAT-Solver nach Gegenbeispielen, und Alloy 6 erg\xE4nzt temporale Operatoren zur Modellierung von Systemverhalten \xFCber die Zeit.\n\nAlloy wird eingesetzt, um Softwaredesigns, Sicherheitsprotokolle und Datenmodelle vor der Implementierung zu pr\xFCfen und subtile Fehler zu finden, die Tests selten erreichen."
+    },
+    pt: {
+      name: "Alloy",
+      description: "Uma linguagem de modelagem relacional com analisador baseado em SAT para achar falhas de projeto.",
+      longDescription: "Alloy \xE9 uma linguagem de modelagem declarativa baseada em l\xF3gica relacional, criada por Daniel Jackson no MIT. Os modelos descrevem estruturas e restri\xE7\xF5es; o Alloy Analyzer busca exaustivamente em escopos limitados com um resolvedor SAT para encontrar contraexemplos, e o Alloy 6 adiciona operadores temporais para modelar o comportamento do sistema ao longo do tempo.\n\nAlloy \xE9 usado para verificar projetos de software, protocolos de seguran\xE7a e modelos de dados antes da implementa\xE7\xE3o, capturando falhas sutis que os testes raramente alcan\xE7am."
+    }
+  }
+};
+
 // src/languages/ampl.ts
 var ampl = {
   slug: "ampl",
@@ -307,7 +482,7 @@ var angelscript = {
     ecosystems: ["Game Development", "Embedded Scripting", "Modding"]
   },
   version: "2.36.1",
-  logo: "https://dummyimage.com/32x32/2D5FA0/ffffff.png&text=AS",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/angelscript.svg",
   color: "#2D5FA0",
   i18n: {
     en: {
@@ -346,6 +521,7 @@ var angelscript = {
 // src/languages/ante.ts
 var ante = {
   slug: "ante",
+  status: "experimental",
   publishedDate: "2019-01-01",
   extensions: [".ante"],
   author: "Evan Haas",
@@ -793,6 +969,7 @@ var asp = {
 // src/languages/assembly.ts
 var assembly = {
   slug: "assembly",
+  aliases: ["asm"],
   publishedDate: "1949-01-01",
   extensions: [".asm", ".s", ".S", ".inc"],
   author: "Machine architecture vendors and assembler implementers",
@@ -848,6 +1025,9 @@ var assemblyscript = {
   author: "Daniel Wirtz / AssemblyScript Contributors",
   website: "https://www.assemblyscript.org",
   paradigms: ["imperative", "object-oriented", "compiled"],
+  relations: {
+    compilesTo: ["webassembly"]
+  },
   tooling: {
     runtimes: ["Wasm", "WASI"],
     ecosystems: ["WebAssembly"]
@@ -942,6 +1122,7 @@ var astro = {
 // src/languages/austral.ts
 var austral = {
   slug: "austral",
+  status: "experimental",
   publishedDate: "2021-01-01",
   extensions: [".aum", ".aui"],
   author: "Fernando Borretti",
@@ -952,7 +1133,7 @@ var austral = {
     ecosystems: ["Systems Programming", "Memory Safety", "Research"]
   },
   version: "0.1.0",
-  logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Au",
+  logo: "https://avatars.githubusercontent.com/u/17337956?v=4",
   color: "#0F766E",
   i18n: {
     en: {
@@ -1383,6 +1564,7 @@ var bazel = {
 // src/languages/bcpl.ts
 var bcpl = {
   slug: "bcpl",
+  status: "historical",
   publishedDate: "1967-01-01",
   extensions: [".bcpl"],
   author: "Martin Richards",
@@ -1393,7 +1575,7 @@ var bcpl = {
     ecosystems: ["Systems Programming", "Operating Systems", "Language History"]
   },
   version: "Cintsys BCPL",
-  logo: "https://dummyimage.com/32x32/374151/ffffff.png&text=BC",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/bcpl.svg",
   color: "#374151",
   i18n: {
     en: {
@@ -1442,7 +1624,7 @@ var bibtex = {
     ecosystems: ["TeX", "LaTeX", "Academic publishing"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Bi",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/9/92/LaTeX_logo.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -1581,6 +1763,7 @@ var blade = {
 // src/languages/bosque.ts
 var bosque = {
   slug: "bosque",
+  status: "experimental",
   publishedDate: "2019-04-15",
   extensions: [".bsq"],
   author: "Microsoft Research",
@@ -1591,7 +1774,7 @@ var bosque = {
     ecosystems: ["Research", "Verification", "Application Logic"]
   },
   version: "experimental",
-  logo: "https://dummyimage.com/32x32/0078D4/ffffff.png&text=B",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/bosque.svg",
   color: "#0078D4",
   i18n: {
     en: {
@@ -1689,7 +1872,7 @@ var brainfuck = {
     ecosystems: ["Esoteric programming"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=BF",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/brainfuck.svg",
   color: "#111827",
   i18n: {
     en: {
@@ -1775,6 +1958,59 @@ var c = {
   }
 };
 
+// src/languages/c3.ts
+var c3 = {
+  slug: "c3",
+  status: "experimental",
+  publishedDate: "2019-07-01",
+  extensions: [".c3", ".c3i"],
+  author: "Christoffer Lern\xF6",
+  website: "https://c3-lang.org",
+  paradigms: ["imperative", "procedural", "systems"],
+  relations: {
+    dialectOf: ["c"]
+  },
+  tooling: {
+    runtimes: ["Native", "LLVM"],
+    ecosystems: ["Systems"]
+  },
+  version: "0.7.5",
+  logo: "https://avatars.githubusercontent.com/u/53541653?v=4",
+  color: "#295B9A",
+  i18n: {
+    en: {
+      name: "C3",
+      description: "An evolution of C with modules, generics, and safety, keeping C ABI compatibility.",
+      longDescription: "C3 is a systems programming language designed as an evolution of C rather than a replacement. It adds modules, semantic macros, generics, slices, optionals, and built-in error handling while staying close to C syntax and remaining fully ABI-compatible with existing C libraries.\n\nCompiled through LLVM, C3 targets the same niches as C \u2014 operating systems, embedded, and game development \u2014 and lets teams adopt it incrementally alongside existing C codebases."
+    },
+    es: {
+      name: "C3",
+      description: "Una evoluci\xF3n de C con m\xF3dulos, gen\xE9ricos y seguridad, manteniendo compatibilidad ABI con C.",
+      longDescription: "C3 es un lenguaje de programaci\xF3n de sistemas dise\xF1ado como una evoluci\xF3n de C y no como un reemplazo. Agrega m\xF3dulos, macros sem\xE1nticas, gen\xE9ricos, slices, opcionales y manejo de errores integrado, manteni\xE9ndose cercano a la sintaxis de C y totalmente compatible a nivel ABI con las bibliotecas C existentes.\n\nCompilado mediante LLVM, C3 apunta a los mismos nichos que C \u2014 sistemas operativos, embebidos y desarrollo de juegos \u2014 y permite adoptarlo de forma incremental junto a bases de c\xF3digo C existentes."
+    },
+    it: {
+      name: "C3",
+      description: "Un'evoluzione di C con moduli, generics e sicurezza, mantenendo la compatibilit\xE0 ABI con C.",
+      longDescription: "C3 \xE8 un linguaggio di programmazione di sistemi progettato come evoluzione di C piuttosto che come sostituto. Aggiunge moduli, macro semantiche, generics, slice, optional e gestione degli errori integrata, restando vicino alla sintassi di C e pienamente compatibile a livello ABI con le librerie C esistenti.\n\nCompilato tramite LLVM, C3 punta alle stesse nicchie di C \u2014 sistemi operativi, embedded e sviluppo di giochi \u2014 e consente un'adozione incrementale accanto alle basi di codice C esistenti."
+    },
+    fr: {
+      name: "C3",
+      description: "Une \xE9volution de C avec modules, g\xE9n\xE9riques et s\xFBret\xE9, compatible ABI avec C.",
+      longDescription: "C3 est un langage de programmation syst\xE8me con\xE7u comme une \xE9volution de C plut\xF4t qu'un remplacement. Il ajoute des modules, des macros s\xE9mantiques, des g\xE9n\xE9riques, des slices, des optionnels et une gestion d'erreurs int\xE9gr\xE9e, tout en restant proche de la syntaxe C et enti\xE8rement compatible ABI avec les biblioth\xE8ques C existantes.\n\nCompil\xE9 via LLVM, C3 vise les m\xEAmes niches que C \u2014 syst\xE8mes d'exploitation, embarqu\xE9 et d\xE9veloppement de jeux \u2014 et permet une adoption progressive aux c\xF4t\xE9s des bases de code C existantes."
+    },
+    de: {
+      name: "C3",
+      description: "Eine Weiterentwicklung von C mit Modulen, Generics und Sicherheit, ABI-kompatibel zu C.",
+      longDescription: "C3 ist eine Systemprogrammiersprache, die als Weiterentwicklung von C und nicht als Ersatz konzipiert ist. Sie erg\xE4nzt Module, semantische Makros, Generics, Slices, Optionals und eingebaute Fehlerbehandlung, bleibt dabei nah an der C-Syntax und vollst\xE4ndig ABI-kompatibel zu bestehenden C-Bibliotheken.\n\n\xDCber LLVM kompiliert, zielt C3 auf dieselben Nischen wie C \u2014 Betriebssysteme, Embedded und Spieleentwicklung \u2014 und l\xE4sst sich schrittweise neben bestehenden C-Codebasen einf\xFChren."
+    },
+    pt: {
+      name: "C3",
+      description: "Uma evolu\xE7\xE3o do C com m\xF3dulos, gen\xE9ricos e seguran\xE7a, mantendo compatibilidade ABI com C.",
+      longDescription: "C3 \xE9 uma linguagem de programa\xE7\xE3o de sistemas projetada como uma evolu\xE7\xE3o do C, n\xE3o um substituto. Adiciona m\xF3dulos, macros sem\xE2nticas, gen\xE9ricos, slices, opcionais e tratamento de erros embutido, mantendo-se pr\xF3xima da sintaxe do C e totalmente compat\xEDvel em n\xEDvel de ABI com bibliotecas C existentes.\n\nCompilada via LLVM, a C3 mira os mesmos nichos do C \u2014 sistemas operacionais, embarcados e desenvolvimento de jogos \u2014 e permite ado\xE7\xE3o incremental ao lado de bases de c\xF3digo C existentes."
+    }
+  }
+};
+
 // src/languages/cairo.ts
 var cairo = {
   slug: "cairo",
@@ -1877,6 +2113,7 @@ var capnproto = {
 // src/languages/carbon.ts
 var carbon = {
   slug: "carbon",
+  status: "experimental",
   publishedDate: "2022-07-19",
   extensions: [".carbon"],
   author: "Carbon Language Project",
@@ -2073,6 +2310,59 @@ var circom = {
   }
 };
 
+// src/languages/clarity.ts
+var clarity = {
+  slug: "clarity",
+  publishedDate: "2021-01-14",
+  extensions: [".clar"],
+  author: "Hiro Systems / Stacks",
+  website: "https://clarity-lang.org",
+  paradigms: ["functional", "declarative", "smart-contract"],
+  relations: {
+    dialectOf: ["lisp"]
+  },
+  tooling: {
+    runtimes: ["Stacks blockchain"],
+    packageManagers: ["Clarinet"],
+    ecosystems: ["Blockchain", "Web3"]
+  },
+  version: "Clarity 3",
+  logo: "https://avatars.githubusercontent.com/u/66125257?v=4",
+  color: "#5546FF",
+  i18n: {
+    en: {
+      name: "Clarity",
+      description: "A decidable, Lisp-like smart contract language for the Stacks Bitcoin layer.",
+      longDescription: "Clarity is the smart contract language of the Stacks blockchain, which settles on Bitcoin. Its Lisp-like syntax is interpreted, not compiled, and the language is intentionally decidable: contracts cannot loop unboundedly, so their cost and behavior can be analyzed before execution.\n\nContracts are published as readable source on-chain, eliminating compiler trust issues. The Clarinet toolchain provides local development, testing, and deployment workflows."
+    },
+    es: {
+      name: "Clarity",
+      description: "Un lenguaje de contratos inteligentes decidible y tipo Lisp para la capa Bitcoin de Stacks.",
+      longDescription: "Clarity es el lenguaje de contratos inteligentes de la blockchain Stacks, que se asienta sobre Bitcoin. Su sintaxis tipo Lisp se interpreta, no se compila, y el lenguaje es intencionalmente decidible: los contratos no pueden iterar sin l\xEDmite, as\xED que su costo y comportamiento pueden analizarse antes de la ejecuci\xF3n.\n\nLos contratos se publican como c\xF3digo fuente legible en la cadena, eliminando problemas de confianza en el compilador. La cadena de herramientas Clarinet ofrece flujos de desarrollo local, pruebas y despliegue."
+    },
+    it: {
+      name: "Clarity",
+      description: "Un linguaggio per smart contract decidibile e in stile Lisp per il layer Bitcoin di Stacks.",
+      longDescription: "Clarity \xE8 il linguaggio per smart contract della blockchain Stacks, che si regola su Bitcoin. La sua sintassi in stile Lisp viene interpretata, non compilata, e il linguaggio \xE8 volutamente decidibile: i contratti non possono iterare senza limiti, quindi costo e comportamento possono essere analizzati prima dell'esecuzione.\n\nI contratti sono pubblicati come sorgente leggibile sulla catena, eliminando i problemi di fiducia nel compilatore. La toolchain Clarinet fornisce flussi di sviluppo locale, test e deployment."
+    },
+    fr: {
+      name: "Clarity",
+      description: "Un langage de smart contracts d\xE9cidable, de type Lisp, pour la couche Bitcoin de Stacks.",
+      longDescription: "Clarity est le langage de smart contracts de la blockchain Stacks, qui se r\xE8gle sur Bitcoin. Sa syntaxe de type Lisp est interpr\xE9t\xE9e, non compil\xE9e, et le langage est volontairement d\xE9cidable : les contrats ne peuvent pas boucler ind\xE9finiment, leur co\xFBt et leur comportement peuvent donc \xEAtre analys\xE9s avant ex\xE9cution.\n\nLes contrats sont publi\xE9s en source lisible sur la cha\xEEne, \xE9liminant les probl\xE8mes de confiance envers le compilateur. La cha\xEEne d'outils Clarinet fournit d\xE9veloppement local, tests et d\xE9ploiement."
+    },
+    de: {
+      name: "Clarity",
+      description: "Eine entscheidbare, Lisp-artige Smart-Contract-Sprache f\xFCr die Bitcoin-Schicht von Stacks.",
+      longDescription: "Clarity ist die Smart-Contract-Sprache der Stacks-Blockchain, die auf Bitcoin abgerechnet wird. Ihre Lisp-artige Syntax wird interpretiert, nicht kompiliert, und die Sprache ist bewusst entscheidbar: Vertr\xE4ge k\xF6nnen nicht unbegrenzt iterieren, sodass Kosten und Verhalten vor der Ausf\xFChrung analysierbar sind.\n\nVertr\xE4ge werden als lesbarer Quelltext on-chain ver\xF6ffentlicht, was Vertrauensprobleme mit Compilern beseitigt. Die Clarinet-Toolchain bietet lokale Entwicklung, Tests und Deployment."
+    },
+    pt: {
+      name: "Clarity",
+      description: "Uma linguagem de contratos inteligentes decid\xEDvel e estilo Lisp para a camada Bitcoin da Stacks.",
+      longDescription: "Clarity \xE9 a linguagem de contratos inteligentes da blockchain Stacks, que se liquida no Bitcoin. Sua sintaxe estilo Lisp \xE9 interpretada, n\xE3o compilada, e a linguagem \xE9 intencionalmente decid\xEDvel: os contratos n\xE3o podem iterar sem limite, ent\xE3o seu custo e comportamento podem ser analisados antes da execu\xE7\xE3o.\n\nOs contratos s\xE3o publicados como c\xF3digo-fonte leg\xEDvel na cadeia, eliminando problemas de confian\xE7a no compilador. A toolchain Clarinet fornece fluxos de desenvolvimento local, testes e implanta\xE7\xE3o."
+    }
+  }
+};
+
 // src/languages/clojure.ts
 var clojure = {
   slug: "clojure",
@@ -2185,7 +2475,7 @@ var cobol = {
     ecosystems: ["Mainframe", "Business applications", "Transaction processing"]
   },
   version: "ISO/IEC 1989:2023",
-  logo: "https://logo.svgcdn.com/devicon/cobol-original.png",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_cobol.svg",
   color: "#005CA5",
   i18n: {
     en: {
@@ -2229,6 +2519,9 @@ var coffeescript = {
   author: "Jeremy Ashkenas",
   website: "https://coffeescript.org",
   paradigms: ["functional", "imperative", "object-oriented", "scripting"],
+  relations: {
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["Browser", "Node.js"],
     packageManagers: ["npm", "pnpm", "Yarn"],
@@ -2324,6 +2617,7 @@ var coldfusion = {
 // src/languages/coq.ts
 var coq = {
   slug: "coq",
+  aliases: ["rocq"],
   publishedDate: "1989-01-01",
   extensions: [".v"],
   author: "INRIA / Rocq Prover Development Team",
@@ -2374,11 +2668,15 @@ var coq = {
 // src/languages/cpp.ts
 var cpp = {
   slug: "cpp",
+  aliases: ["c++", "cplusplus"],
   publishedDate: "1985-10-01",
   extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"],
   author: "Bjarne Stroustrup",
   website: "https://isocpp.org",
   paradigms: ["procedural", "object-oriented", "generic", "functional"],
+  relations: {
+    supersetOf: ["c"]
+  },
   tooling: {
     runtimes: ["Native"],
     packageManagers: ["Conan", "vcpkg"],
@@ -2523,6 +2821,7 @@ var crystal = {
 // src/languages/csharp.ts
 var csharp = {
   slug: "csharp",
+  aliases: ["c#", "cs"],
   publishedDate: "2000-06-26",
   extensions: [".cs", ".csx"],
   author: "Anders Hejlsberg / Microsoft",
@@ -2765,6 +3064,55 @@ var curry = {
   }
 };
 
+// src/languages/cwl.ts
+var cwl = {
+  slug: "cwl",
+  publishedDate: "2016-07-08",
+  extensions: [".cwl"],
+  author: "Common Workflow Language project",
+  website: "https://www.commonwl.org",
+  paradigms: ["declarative", "workflow"],
+  tooling: {
+    runtimes: ["cwltool", "Toil", "Arvados"],
+    ecosystems: ["Bioinformatics", "Scientific Computing", "HPC"]
+  },
+  version: "v1.2",
+  logo: "https://avatars.githubusercontent.com/u/9947495?v=4",
+  color: "#B5314C",
+  i18n: {
+    en: {
+      name: "Common Workflow Language",
+      description: "An open standard for describing portable, reproducible data-analysis workflows.",
+      longDescription: "The Common Workflow Language (CWL) is an open standard for describing command-line tools and connecting them into workflows, expressed in YAML/JSON documents. Explicit inputs, outputs, and container requirements make workflows portable across laptops, clusters, and clouds.\n\nCWL is widely adopted in bioinformatics and scientific computing, with implementations such as cwltool, Toil, and Arvados executing the same workflow description on very different infrastructure."
+    },
+    es: {
+      name: "Common Workflow Language",
+      description: "Un est\xE1ndar abierto para describir flujos de an\xE1lisis de datos portables y reproducibles.",
+      longDescription: "El Common Workflow Language (CWL) es un est\xE1ndar abierto para describir herramientas de l\xEDnea de comandos y conectarlas en flujos de trabajo, expresados en documentos YAML/JSON. Las entradas, salidas y requisitos de contenedores expl\xEDcitos hacen que los flujos sean portables entre port\xE1tiles, cl\xFAsteres y nubes.\n\nCWL est\xE1 ampliamente adoptado en bioinform\xE1tica y computaci\xF3n cient\xEDfica, con implementaciones como cwltool, Toil y Arvados que ejecutan la misma descripci\xF3n de flujo en infraestructuras muy distintas."
+    },
+    it: {
+      name: "Common Workflow Language",
+      description: "Uno standard aperto per descrivere flussi di analisi dati portabili e riproducibili.",
+      longDescription: "Il Common Workflow Language (CWL) \xE8 uno standard aperto per descrivere strumenti da riga di comando e collegarli in flussi di lavoro, espressi in documenti YAML/JSON. Input, output e requisiti dei container espliciti rendono i flussi portabili tra laptop, cluster e cloud.\n\nCWL \xE8 ampiamente adottato nella bioinformatica e nel calcolo scientifico, con implementazioni come cwltool, Toil e Arvados che eseguono la stessa descrizione di workflow su infrastrutture molto diverse."
+    },
+    fr: {
+      name: "Common Workflow Language",
+      description: "Un standard ouvert pour d\xE9crire des workflows d'analyse de donn\xE9es portables et reproductibles.",
+      longDescription: "Le Common Workflow Language (CWL) est un standard ouvert pour d\xE9crire des outils en ligne de commande et les relier en workflows, exprim\xE9s dans des documents YAML/JSON. Des entr\xE9es, sorties et exigences de conteneurs explicites rendent les workflows portables entre ordinateurs portables, clusters et clouds.\n\nCWL est largement adopt\xE9 en bio-informatique et en calcul scientifique, avec des impl\xE9mentations comme cwltool, Toil et Arvados ex\xE9cutant la m\xEAme description de workflow sur des infrastructures tr\xE8s diff\xE9rentes."
+    },
+    de: {
+      name: "Common Workflow Language",
+      description: "Ein offener Standard zur Beschreibung portabler, reproduzierbarer Datenanalyse-Workflows.",
+      longDescription: "Die Common Workflow Language (CWL) ist ein offener Standard, um Kommandozeilenwerkzeuge zu beschreiben und zu Workflows zu verbinden, ausgedr\xFCckt in YAML/JSON-Dokumenten. Explizite Eingaben, Ausgaben und Container-Anforderungen machen Workflows \xFCber Laptops, Cluster und Clouds hinweg portabel.\n\nCWL ist in der Bioinformatik und im wissenschaftlichen Rechnen weit verbreitet; Implementierungen wie cwltool, Toil und Arvados f\xFChren dieselbe Workflow-Beschreibung auf sehr unterschiedlicher Infrastruktur aus."
+    },
+    pt: {
+      name: "Common Workflow Language",
+      description: "Um padr\xE3o aberto para descrever fluxos de an\xE1lise de dados port\xE1veis e reproduz\xEDveis.",
+      longDescription: "O Common Workflow Language (CWL) \xE9 um padr\xE3o aberto para descrever ferramentas de linha de comando e conect\xE1-las em fluxos de trabalho, expressos em documentos YAML/JSON. Entradas, sa\xEDdas e requisitos de cont\xEAineres expl\xEDcitos tornam os fluxos port\xE1veis entre laptops, clusters e nuvens.\n\nO CWL \xE9 amplamente adotado em bioinform\xE1tica e computa\xE7\xE3o cient\xEDfica, com implementa\xE7\xF5es como cwltool, Toil e Arvados executando a mesma descri\xE7\xE3o de workflow em infraestruturas muito diferentes."
+    }
+  }
+};
+
 // src/languages/cypher.ts
 var cypher = {
   slug: "cypher",
@@ -2822,6 +3170,10 @@ var cython = {
   author: "Robert Bradshaw, Stefan Behnel, Dag Sverre Seljebotn, Greg Ewing, et al.",
   website: "https://cython.org",
   paradigms: ["object-oriented", "imperative", "procedural"],
+  relations: {
+    supersetOf: ["python"],
+    compilesTo: ["c"]
+  },
   tooling: {
     runtimes: ["CPython"],
     packageManagers: ["pip", "conda", "Poetry"],
@@ -2972,6 +3324,9 @@ var dart = {
   author: "Google",
   website: "https://dart.dev",
   paradigms: ["class-based", "functional", "object-oriented", "structured"],
+  relations: {
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["Dart VM", "Dart Native", "JavaScript"],
     packageManagers: ["pub"],
@@ -3031,7 +3386,7 @@ var dax = {
     ]
   },
   version: "DAX 2025",
-  logo: "https://dummyimage.com/32x32/F2C811/000000.png&text=DAX",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/c/cf/New_Power_BI_Logo.svg",
   color: "#F2C811",
   i18n: {
     en: {
@@ -3170,6 +3525,7 @@ var dita = {
 // src/languages/dockerfile.ts
 var dockerfile = {
   slug: "dockerfile",
+  aliases: ["docker"],
   publishedDate: "2013-03-20",
   extensions: ["Dockerfile", ".dockerfile"],
   author: "Docker, Inc.",
@@ -3315,6 +3671,56 @@ var earthly = {
   }
 };
 
+// src/languages/edgeql.ts
+var edgeql = {
+  slug: "edgeql",
+  aliases: ["gel"],
+  publishedDate: "2022-02-10",
+  extensions: [".edgeql"],
+  author: "EdgeDB (Gel Data)",
+  website: "https://www.geldata.com",
+  paradigms: ["declarative", "functional", "query"],
+  tooling: {
+    runtimes: ["Gel", "EdgeDB"],
+    ecosystems: ["Databases"]
+  },
+  version: "Gel 6",
+  logo: "https://avatars.githubusercontent.com/u/200293856?v=4",
+  color: "#6963FF",
+  i18n: {
+    en: {
+      name: "EdgeQL",
+      description: "The composable query language of the Gel (formerly EdgeDB) graph-relational database.",
+      longDescription: "EdgeQL is the query language of Gel (formerly EdgeDB), a database that layers an object-and-link data model over PostgreSQL. Queries traverse relationships with paths instead of joins, nest naturally to return structured results, and compose like expressions rather than statements.\n\nBacked by a strict type system and a migration-aware schema language, EdgeQL eliminates common ORM problems \u2014 N+1 queries, impedance mismatch \u2014 while retaining the reliability of PostgreSQL underneath."
+    },
+    es: {
+      name: "EdgeQL",
+      description: "El lenguaje de consultas componible de la base de datos grafo-relacional Gel (antes EdgeDB).",
+      longDescription: "EdgeQL es el lenguaje de consultas de Gel (antes EdgeDB), una base de datos que superpone un modelo de objetos y enlaces sobre PostgreSQL. Las consultas recorren relaciones con rutas en lugar de joins, se anidan de forma natural para devolver resultados estructurados y se componen como expresiones y no como sentencias.\n\nRespaldado por un sistema de tipos estricto y un lenguaje de esquemas con migraciones, EdgeQL elimina problemas comunes de los ORM \u2014 consultas N+1, desajuste de impedancia \u2014 conservando la fiabilidad de PostgreSQL por debajo."
+    },
+    it: {
+      name: "EdgeQL",
+      description: "Il linguaggio di query componibile del database grafo-relazionale Gel (ex EdgeDB).",
+      longDescription: "EdgeQL \xE8 il linguaggio di query di Gel (ex EdgeDB), un database che sovrappone un modello di oggetti e collegamenti a PostgreSQL. Le query attraversano le relazioni con percorsi invece di join, si annidano naturalmente per restituire risultati strutturati e si compongono come espressioni anzich\xE9 istruzioni.\n\nSostenuto da un sistema di tipi rigoroso e da un linguaggio di schema con migrazioni, EdgeQL elimina i problemi comuni degli ORM \u2014 query N+1, disallineamento di impedenza \u2014 mantenendo sotto l'affidabilit\xE0 di PostgreSQL."
+    },
+    fr: {
+      name: "EdgeQL",
+      description: "Le langage de requ\xEAte composable de la base graphe-relationnelle Gel (ex-EdgeDB).",
+      longDescription: "EdgeQL est le langage de requ\xEAte de Gel (anciennement EdgeDB), une base de donn\xE9es qui superpose un mod\xE8le d'objets et de liens \xE0 PostgreSQL. Les requ\xEAtes parcourent les relations par des chemins plut\xF4t que des jointures, s'imbriquent naturellement pour renvoyer des r\xE9sultats structur\xE9s et se composent comme des expressions plut\xF4t que des instructions.\n\nAdoss\xE9 \xE0 un syst\xE8me de types strict et \xE0 un langage de sch\xE9ma avec migrations, EdgeQL \xE9limine les probl\xE8mes courants des ORM \u2014 requ\xEAtes N+1, d\xE9sadaptation d'imp\xE9dance \u2014 tout en conservant la fiabilit\xE9 de PostgreSQL en dessous."
+    },
+    de: {
+      name: "EdgeQL",
+      description: "Die komponierbare Abfragesprache der graph-relationalen Datenbank Gel (fr\xFCher EdgeDB).",
+      longDescription: "EdgeQL ist die Abfragesprache von Gel (fr\xFCher EdgeDB), einer Datenbank, die ein Objekt-und-Link-Datenmodell \xFCber PostgreSQL legt. Abfragen folgen Beziehungen \xFCber Pfade statt Joins, verschachteln sich nat\xFCrlich zu strukturierten Ergebnissen und komponieren wie Ausdr\xFCcke statt wie Anweisungen.\n\nGest\xFCtzt auf ein striktes Typsystem und eine migrationsbewusste Schemasprache beseitigt EdgeQL typische ORM-Probleme \u2014 N+1-Abfragen, Impedanz-Missverh\xE4ltnis \u2014 und beh\xE4lt darunter die Zuverl\xE4ssigkeit von PostgreSQL."
+    },
+    pt: {
+      name: "EdgeQL",
+      description: "A linguagem de consulta compon\xEDvel do banco grafo-relacional Gel (antes EdgeDB).",
+      longDescription: "EdgeQL \xE9 a linguagem de consulta do Gel (antes EdgeDB), um banco de dados que sobrep\xF5e um modelo de objetos e v\xEDnculos ao PostgreSQL. As consultas percorrem relacionamentos com caminhos em vez de joins, aninham-se naturalmente para retornar resultados estruturados e comp\xF5em-se como express\xF5es em vez de comandos.\n\nApoiado por um sistema de tipos estrito e uma linguagem de esquema com migra\xE7\xF5es, o EdgeQL elimina problemas comuns de ORMs \u2014 consultas N+1, descasamento de imped\xE2ncia \u2014 mantendo por baixo a confiabilidade do PostgreSQL."
+    }
+  }
+};
+
 // src/languages/editorconfig.ts
 var editorconfig = {
   slug: "editorconfig",
@@ -3521,6 +3927,9 @@ var elm = {
   author: "Evan Czaplicki",
   website: "https://elm-lang.org",
   paradigms: ["functional", "declarative", "reactive", "statically typed"],
+  relations: {
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["Browser", "JavaScript"],
     packageManagers: ["elm", "npm", "pnpm", "Yarn"],
@@ -3563,13 +3972,67 @@ var elm = {
   }
 };
 
+// src/languages/emacs-lisp.ts
+var emacsLisp = {
+  slug: "emacs-lisp",
+  aliases: ["elisp"],
+  publishedDate: "1985-03-20",
+  extensions: [".el"],
+  author: "Richard Stallman / GNU Project",
+  website: "https://www.gnu.org/software/emacs/manual/elisp.html",
+  paradigms: ["functional", "imperative", "meta-programming", "scripting"],
+  relations: {
+    dialectOf: ["lisp"]
+  },
+  tooling: {
+    runtimes: ["GNU Emacs"],
+    packageManagers: ["package.el", "ELPA", "MELPA"],
+    ecosystems: ["Text Editors", "Scripting"]
+  },
+  version: "Emacs 30.1",
+  logo: "https://cdn.simpleicons.org/gnuemacs/7F5AB6",
+  color: "#7F5AB6",
+  i18n: {
+    en: {
+      name: "Emacs Lisp",
+      description: "The Lisp dialect used to implement and extend the GNU Emacs editor.",
+      longDescription: "Emacs Lisp is a dialect of Lisp that powers most of the GNU Emacs editor. Beyond configuration, it is a complete programming language with dynamic and lexical binding, macros, and an interactive development workflow built into the editor itself.\n\nThousands of packages distributed through ELPA and MELPA are written in Emacs Lisp, covering everything from mail clients and file managers to language servers and note-taking systems such as Org mode."
+    },
+    es: {
+      name: "Emacs Lisp",
+      description: "El dialecto de Lisp usado para implementar y extender el editor GNU Emacs.",
+      longDescription: "Emacs Lisp es un dialecto de Lisp que impulsa la mayor parte del editor GNU Emacs. M\xE1s all\xE1 de la configuraci\xF3n, es un lenguaje de programaci\xF3n completo con enlace din\xE1mico y l\xE9xico, macros y un flujo de desarrollo interactivo integrado en el propio editor.\n\nMiles de paquetes distribuidos a trav\xE9s de ELPA y MELPA est\xE1n escritos en Emacs Lisp, cubriendo desde clientes de correo y gestores de archivos hasta servidores de lenguaje y sistemas de notas como Org mode."
+    },
+    it: {
+      name: "Emacs Lisp",
+      description: "Il dialetto Lisp usato per implementare ed estendere l'editor GNU Emacs.",
+      longDescription: "Emacs Lisp \xE8 un dialetto di Lisp che alimenta la maggior parte dell'editor GNU Emacs. Oltre alla configurazione, \xE8 un linguaggio di programmazione completo con binding dinamico e lessicale, macro e un flusso di sviluppo interattivo integrato nell'editor stesso.\n\nMigliaia di pacchetti distribuiti tramite ELPA e MELPA sono scritti in Emacs Lisp, coprendo di tutto: client di posta, gestori di file, language server e sistemi di appunti come Org mode."
+    },
+    fr: {
+      name: "Emacs Lisp",
+      description: "Le dialecte Lisp utilis\xE9 pour impl\xE9menter et \xE9tendre l'\xE9diteur GNU Emacs.",
+      longDescription: "Emacs Lisp est un dialecte de Lisp qui fait fonctionner la majeure partie de l'\xE9diteur GNU Emacs. Au-del\xE0 de la configuration, c'est un langage de programmation complet avec liaison dynamique et lexicale, macros et un flux de d\xE9veloppement interactif int\xE9gr\xE9 \xE0 l'\xE9diteur lui-m\xEAme.\n\nDes milliers de paquets distribu\xE9s via ELPA et MELPA sont \xE9crits en Emacs Lisp, couvrant aussi bien des clients de messagerie et des gestionnaires de fichiers que des serveurs de langage et des syst\xE8mes de prise de notes comme Org mode."
+    },
+    de: {
+      name: "Emacs Lisp",
+      description: "Der Lisp-Dialekt, mit dem der GNU-Emacs-Editor implementiert und erweitert wird.",
+      longDescription: "Emacs Lisp ist ein Lisp-Dialekt, der den gr\xF6\xDFten Teil des GNU-Emacs-Editors antreibt. \xDCber die Konfiguration hinaus ist es eine vollst\xE4ndige Programmiersprache mit dynamischer und lexikalischer Bindung, Makros und einem interaktiven Entwicklungsworkflow direkt im Editor.\n\nTausende \xFCber ELPA und MELPA verteilte Pakete sind in Emacs Lisp geschrieben und decken alles ab: von Mail-Clients und Dateimanagern bis zu Language-Servern und Notizsystemen wie Org mode."
+    },
+    pt: {
+      name: "Emacs Lisp",
+      description: "O dialeto de Lisp usado para implementar e estender o editor GNU Emacs.",
+      longDescription: "Emacs Lisp \xE9 um dialeto de Lisp que move a maior parte do editor GNU Emacs. Al\xE9m da configura\xE7\xE3o, \xE9 uma linguagem de programa\xE7\xE3o completa com liga\xE7\xE3o din\xE2mica e l\xE9xica, macros e um fluxo de desenvolvimento interativo integrado ao pr\xF3prio editor.\n\nMilhares de pacotes distribu\xEDdos via ELPA e MELPA s\xE3o escritos em Emacs Lisp, cobrindo de clientes de e-mail e gerenciadores de arquivos a servidores de linguagem e sistemas de notas como o Org mode."
+    }
+  }
+};
+
 // src/languages/erb.ts
 var erb = {
   slug: "erb",
   publishedDate: "2000-01-01",
   extensions: [".erb", ".rhtml", ".html.erb"],
   author: "Masatoshi Seki / Ruby",
-  website: "https://ruby-doc.org/stdlib/erb/",
+  website: "https://docs.ruby-lang.org/en/master/ERB.html",
   paradigms: ["templating", "embedded", "markup"],
   tooling: {
     runtimes: ["Ruby", "Ruby on Rails"],
@@ -3713,9 +4176,62 @@ var factor = {
   }
 };
 
+// src/languages/faust.ts
+var faust = {
+  slug: "faust",
+  publishedDate: "2002-01-01",
+  extensions: [".dsp"],
+  author: "GRAME-CNCM",
+  website: "https://faust.grame.fr",
+  paradigms: ["functional", "dataflow", "audio"],
+  relations: {
+    compilesTo: ["cpp", "webassembly"]
+  },
+  tooling: {
+    runtimes: ["Native", "Browser", "Embedded DSP"],
+    ecosystems: ["Audio", "Music", "DSP"]
+  },
+  version: "stable",
+  logo: "https://faust.grame.fr/img/faustText.svg",
+  color: "#C6613F",
+  i18n: {
+    en: {
+      name: "Faust",
+      description: "A functional language for real-time audio DSP that compiles to C++, WebAssembly, and more.",
+      longDescription: "Faust (Functional Audio Stream) is a functional language for real-time signal processing developed at GRAME. Programs describe audio processors as block-diagram compositions of signal functions, which the compiler translates into highly optimized C++, WebAssembly, LLVM IR, or Rust.\n\nFrom one Faust source, build tools generate VST/AU plugins, standalone applications, microcontroller firmware, and web audio nodes \u2014 making it a standard tool for synthesizer, effect, and audio-research development."
+    },
+    es: {
+      name: "Faust",
+      description: "Un lenguaje funcional para DSP de audio en tiempo real que compila a C++, WebAssembly y m\xE1s.",
+      longDescription: "Faust (Functional Audio Stream) es un lenguaje funcional para procesamiento de se\xF1ales en tiempo real desarrollado en GRAME. Los programas describen procesadores de audio como composiciones en diagrama de bloques de funciones de se\xF1al, que el compilador traduce a C++, WebAssembly, LLVM IR o Rust altamente optimizados.\n\nDesde una sola fuente Faust, las herramientas generan plugins VST/AU, aplicaciones independientes, firmware para microcontroladores y nodos de audio web \u2014 una herramienta est\xE1ndar para el desarrollo de sintetizadores, efectos e investigaci\xF3n de audio."
+    },
+    it: {
+      name: "Faust",
+      description: "Un linguaggio funzionale per DSP audio in tempo reale che compila in C++, WebAssembly e altro.",
+      longDescription: "Faust (Functional Audio Stream) \xE8 un linguaggio funzionale per l'elaborazione dei segnali in tempo reale sviluppato al GRAME. I programmi descrivono processori audio come composizioni a diagramma a blocchi di funzioni di segnale, che il compilatore traduce in C++, WebAssembly, LLVM IR o Rust altamente ottimizzati.\n\nDa un'unica sorgente Faust, gli strumenti di build generano plugin VST/AU, applicazioni standalone, firmware per microcontrollori e nodi web audio \u2014 uno strumento standard per lo sviluppo di sintetizzatori, effetti e ricerca audio."
+    },
+    fr: {
+      name: "Faust",
+      description: "Un langage fonctionnel pour le DSP audio temps r\xE9el, compilant vers C++, WebAssembly et plus.",
+      longDescription: "Faust (Functional Audio Stream) est un langage fonctionnel pour le traitement du signal en temps r\xE9el d\xE9velopp\xE9 au GRAME. Les programmes d\xE9crivent des processeurs audio comme des compositions en sch\xE9ma-bloc de fonctions de signal, que le compilateur traduit en C++, WebAssembly, LLVM IR ou Rust hautement optimis\xE9s.\n\n\xC0 partir d'une m\xEAme source Faust, les outils g\xE9n\xE8rent des plugins VST/AU, des applications autonomes, du firmware pour microcontr\xF4leurs et des n\u0153uds web audio \u2014 un outil standard pour le d\xE9veloppement de synth\xE9tiseurs, d'effets et la recherche audio."
+    },
+    de: {
+      name: "Faust",
+      description: "Eine funktionale Sprache f\xFCr Echtzeit-Audio-DSP, die zu C++, WebAssembly und mehr kompiliert.",
+      longDescription: "Faust (Functional Audio Stream) ist eine am GRAME entwickelte funktionale Sprache f\xFCr Echtzeit-Signalverarbeitung. Programme beschreiben Audioprozessoren als Blockdiagramm-Kompositionen von Signalfunktionen, die der Compiler in hochoptimiertes C++, WebAssembly, LLVM IR oder Rust \xFCbersetzt.\n\nAus einer Faust-Quelle erzeugen die Build-Werkzeuge VST/AU-Plugins, eigenst\xE4ndige Anwendungen, Mikrocontroller-Firmware und Web-Audio-Knoten \u2014 ein Standardwerkzeug f\xFCr Synthesizer-, Effekt- und Audio-Forschungsentwicklung."
+    },
+    pt: {
+      name: "Faust",
+      description: "Uma linguagem funcional para DSP de \xE1udio em tempo real que compila para C++, WebAssembly e mais.",
+      longDescription: "Faust (Functional Audio Stream) \xE9 uma linguagem funcional para processamento de sinais em tempo real desenvolvida no GRAME. Os programas descrevem processadores de \xE1udio como composi\xE7\xF5es em diagrama de blocos de fun\xE7\xF5es de sinal, que o compilador traduz em C++, WebAssembly, LLVM IR ou Rust altamente otimizados.\n\nDe uma \xFAnica fonte Faust, as ferramentas de build geram plugins VST/AU, aplica\xE7\xF5es independentes, firmware para microcontroladores e n\xF3s de web audio \u2014 uma ferramenta padr\xE3o para o desenvolvimento de sintetizadores, efeitos e pesquisa em \xE1udio."
+    }
+  }
+};
+
 // src/languages/fe.ts
 var fe = {
   slug: "fe",
+  status: "experimental",
   publishedDate: "2020-10-08",
   extensions: [".fe"],
   author: "Ethereum Foundation contributors",
@@ -3770,6 +4286,9 @@ var fennel = {
   author: "Calvin Rose, Phil Hagelberg",
   website: "https://fennel-lang.org",
   paradigms: ["functional", "lisp", "scripting", "metaprogramming"],
+  relations: {
+    compilesTo: ["lua"]
+  },
   tooling: {
     runtimes: ["Lua", "LuaJIT"],
     packageManagers: ["LuaRocks"],
@@ -3911,6 +4430,56 @@ var flatbuffers = {
   }
 };
 
+// src/languages/flix.ts
+var flix = {
+  slug: "flix",
+  publishedDate: "2016-01-01",
+  extensions: [".flix"],
+  author: "Magnus Madsen / Aarhus University",
+  website: "https://flix.dev",
+  paradigms: ["functional", "imperative", "logic", "concurrent"],
+  tooling: {
+    runtimes: ["JVM"],
+    packageManagers: ["Flix package manager"],
+    ecosystems: ["JVM"]
+  },
+  version: "0.60.0",
+  logo: "https://avatars.githubusercontent.com/u/16831634?v=4",
+  color: "#2D2A55",
+  i18n: {
+    en: {
+      name: "Flix",
+      description: "A JVM language combining functional, imperative, and Datalog-style logic programming.",
+      longDescription: "Flix is a statically typed language for the JVM that blends functional programming with algebraic effects, channels and processes for concurrency, and first-class Datalog constraints for logic programming. Its type and effect system tracks purity, enabling safe parallelism and aggressive optimization.\n\nDeveloped as a research language at Aarhus University with an open-source community, Flix ships a complete toolchain \u2014 compiler, build tool, package manager, and Visual Studio Code extension."
+    },
+    es: {
+      name: "Flix",
+      description: "Un lenguaje JVM que combina programaci\xF3n funcional, imperativa y l\xF3gica estilo Datalog.",
+      longDescription: "Flix es un lenguaje de tipado est\xE1tico para la JVM que mezcla programaci\xF3n funcional con efectos algebraicos, canales y procesos para concurrencia, y restricciones Datalog de primera clase para programaci\xF3n l\xF3gica. Su sistema de tipos y efectos rastrea la pureza, habilitando paralelismo seguro y optimizaci\xF3n agresiva.\n\nDesarrollado como lenguaje de investigaci\xF3n en la Universidad de Aarhus con una comunidad de c\xF3digo abierto, Flix incluye una cadena de herramientas completa: compilador, herramienta de build, gestor de paquetes y extensi\xF3n para Visual Studio Code."
+    },
+    it: {
+      name: "Flix",
+      description: "Un linguaggio JVM che combina programmazione funzionale, imperativa e logica in stile Datalog.",
+      longDescription: "Flix \xE8 un linguaggio a tipizzazione statica per la JVM che unisce la programmazione funzionale con effetti algebrici, canali e processi per la concorrenza, e vincoli Datalog di prima classe per la programmazione logica. Il suo sistema di tipi ed effetti traccia la purezza, abilitando parallelismo sicuro e ottimizzazioni aggressive.\n\nSviluppato come linguaggio di ricerca all'Universit\xE0 di Aarhus con una comunit\xE0 open source, Flix offre una toolchain completa: compilatore, strumento di build, gestore di pacchetti ed estensione per Visual Studio Code."
+    },
+    fr: {
+      name: "Flix",
+      description: "Un langage JVM combinant programmation fonctionnelle, imp\xE9rative et logique de type Datalog.",
+      longDescription: "Flix est un langage \xE0 typage statique pour la JVM qui marie la programmation fonctionnelle avec des effets alg\xE9briques, des canaux et des processus pour la concurrence, et des contraintes Datalog de premi\xE8re classe pour la programmation logique. Son syst\xE8me de types et d'effets suit la puret\xE9, permettant un parall\xE9lisme s\xFBr et des optimisations agressives.\n\nD\xE9velopp\xE9 comme langage de recherche \xE0 l'universit\xE9 d'Aarhus avec une communaut\xE9 open source, Flix fournit une cha\xEEne d'outils compl\xE8te : compilateur, outil de build, gestionnaire de paquets et extension Visual Studio Code."
+    },
+    de: {
+      name: "Flix",
+      description: "Eine JVM-Sprache, die funktionale, imperative und Datalog-artige Logikprogrammierung vereint.",
+      longDescription: "Flix ist eine statisch typisierte Sprache f\xFCr die JVM, die funktionale Programmierung mit algebraischen Effekten, Kan\xE4len und Prozessen f\xFCr Nebenl\xE4ufigkeit sowie erstklassigen Datalog-Constraints f\xFCr Logikprogrammierung verbindet. Ihr Typ- und Effektsystem verfolgt Reinheit und erm\xF6glicht sichere Parallelit\xE4t und aggressive Optimierung.\n\nAls Forschungssprache an der Universit\xE4t Aarhus mit einer Open-Source-Community entwickelt, liefert Flix eine vollst\xE4ndige Toolchain: Compiler, Build-Tool, Paketmanager und Visual-Studio-Code-Erweiterung."
+    },
+    pt: {
+      name: "Flix",
+      description: "Uma linguagem JVM que combina programa\xE7\xE3o funcional, imperativa e l\xF3gica estilo Datalog.",
+      longDescription: "Flix \xE9 uma linguagem de tipagem est\xE1tica para a JVM que mistura programa\xE7\xE3o funcional com efeitos alg\xE9bricos, canais e processos para concorr\xEAncia, e restri\xE7\xF5es Datalog de primeira classe para programa\xE7\xE3o l\xF3gica. Seu sistema de tipos e efeitos rastreia a pureza, permitindo paralelismo seguro e otimiza\xE7\xE3o agressiva.\n\nDesenvolvida como linguagem de pesquisa na Universidade de Aarhus com uma comunidade de c\xF3digo aberto, a Flix traz uma toolchain completa: compilador, ferramenta de build, gerenciador de pacotes e extens\xE3o para o Visual Studio Code."
+    }
+  }
+};
+
 // src/languages/flux.ts
 var flux = {
   slug: "flux",
@@ -4065,7 +4634,7 @@ var fql = {
   publishedDate: "2012-01-01",
   extensions: [".fql"],
   author: "Facebook",
-  website: "https://developers.facebook.com/docs/reference/fql/",
+  website: "https://developers.facebook.com/docs/graph-api/",
   paradigms: ["query", "declarative"],
   tooling: {
     runtimes: ["Facebook Platform"],
@@ -4161,6 +4730,7 @@ var freemarker = {
 // src/languages/fsharp.ts
 var fsharp = {
   slug: "fsharp",
+  aliases: ["f#"],
   publishedDate: "2005-05-01",
   extensions: [".fs", ".fsi", ".fsx", ".fsscript"],
   author: "Don Syme / Microsoft Research",
@@ -4258,6 +4828,59 @@ var fstar = {
   }
 };
 
+// src/languages/futhark.ts
+var futhark = {
+  slug: "futhark",
+  status: "experimental",
+  publishedDate: "2014-01-01",
+  extensions: [".fut"],
+  author: "Troels Henriksen / DIKU, University of Copenhagen",
+  website: "https://futhark-lang.org",
+  paradigms: ["functional", "array", "parallel"],
+  relations: {
+    compilesTo: ["c"]
+  },
+  tooling: {
+    runtimes: ["OpenCL", "CUDA", "Multicore CPU"],
+    ecosystems: ["GPU", "HPC", "Scientific Computing"]
+  },
+  version: "0.25.32",
+  logo: "https://raw.githubusercontent.com/diku-dk/futhark/master/assets/logo.svg",
+  color: "#5F021F",
+  i18n: {
+    en: {
+      name: "Futhark",
+      description: "A purely functional array language that compiles to fast GPU code.",
+      longDescription: "Futhark is a purely functional, data-parallel array language developed at DIKU. Programs express computation as bulk operations \u2014 map, reduce, scan \u2014 over multidimensional arrays, which the optimizing compiler fuses and flattens into efficient OpenCL, CUDA, or multicore C code.\n\nFuthark is not a general-purpose language: it is designed to write the numeric cores of larger applications, exposing them as C libraries callable from Python, Rust, or any FFI-capable host."
+    },
+    es: {
+      name: "Futhark",
+      description: "Un lenguaje de arrays puramente funcional que compila a c\xF3digo GPU r\xE1pido.",
+      longDescription: "Futhark es un lenguaje de arrays puramente funcional y data-paralelo desarrollado en DIKU. Los programas expresan la computaci\xF3n como operaciones masivas \u2014 map, reduce, scan \u2014 sobre arrays multidimensionales, que el compilador optimizador fusiona y aplana en c\xF3digo OpenCL, CUDA o C multin\xFAcleo eficiente.\n\nFuthark no es un lenguaje de prop\xF3sito general: est\xE1 dise\xF1ado para escribir los n\xFAcleos num\xE9ricos de aplicaciones m\xE1s grandes, exponi\xE9ndolos como bibliotecas C invocables desde Python, Rust o cualquier host con FFI."
+    },
+    it: {
+      name: "Futhark",
+      description: "Un linguaggio di array puramente funzionale che compila in codice GPU veloce.",
+      longDescription: "Futhark \xE8 un linguaggio di array puramente funzionale e data-parallelo sviluppato al DIKU. I programmi esprimono la computazione come operazioni di massa \u2014 map, reduce, scan \u2014 su array multidimensionali, che il compilatore ottimizzante fonde e appiattisce in codice OpenCL, CUDA o C multicore efficiente.\n\nFuthark non \xE8 un linguaggio general-purpose: \xE8 progettato per scrivere i nuclei numerici di applicazioni pi\xF9 grandi, esponendoli come librerie C richiamabili da Python, Rust o qualsiasi host con FFI."
+    },
+    fr: {
+      name: "Futhark",
+      description: "Un langage de tableaux purement fonctionnel qui compile en code GPU rapide.",
+      longDescription: "Futhark est un langage de tableaux purement fonctionnel et data-parall\xE8le d\xE9velopp\xE9 au DIKU. Les programmes expriment le calcul sous forme d'op\xE9rations massives \u2014 map, reduce, scan \u2014 sur des tableaux multidimensionnels, que le compilateur optimisant fusionne et aplatit en code OpenCL, CUDA ou C multic\u0153ur efficace.\n\nFuthark n'est pas un langage g\xE9n\xE9raliste : il est con\xE7u pour \xE9crire les c\u0153urs num\xE9riques d'applications plus larges, expos\xE9s comme des biblioth\xE8ques C appelables depuis Python, Rust ou tout h\xF4te dot\xE9 d'une FFI."
+    },
+    de: {
+      name: "Futhark",
+      description: "Eine rein funktionale Array-Sprache, die zu schnellem GPU-Code kompiliert.",
+      longDescription: "Futhark ist eine rein funktionale, datenparallele Array-Sprache, die am DIKU entwickelt wird. Programme dr\xFCcken Berechnungen als Massenoperationen \u2014 map, reduce, scan \u2014 \xFCber mehrdimensionale Arrays aus, die der optimierende Compiler zu effizientem OpenCL-, CUDA- oder Multicore-C-Code fusioniert und abflacht.\n\nFuthark ist keine Allzwecksprache: Sie ist daf\xFCr gedacht, die numerischen Kerne gr\xF6\xDFerer Anwendungen zu schreiben und sie als C-Bibliotheken bereitzustellen, die aus Python, Rust oder jedem FFI-f\xE4higen Host aufrufbar sind."
+    },
+    pt: {
+      name: "Futhark",
+      description: "Uma linguagem de arrays puramente funcional que compila para c\xF3digo GPU r\xE1pido.",
+      longDescription: "Futhark \xE9 uma linguagem de arrays puramente funcional e data-paralela desenvolvida no DIKU. Os programas expressam a computa\xE7\xE3o como opera\xE7\xF5es em massa \u2014 map, reduce, scan \u2014 sobre arrays multidimensionais, que o compilador otimizador funde e achata em c\xF3digo OpenCL, CUDA ou C multicore eficiente.\n\nFuthark n\xE3o \xE9 uma linguagem de prop\xF3sito geral: foi projetada para escrever os n\xFAcleos num\xE9ricos de aplica\xE7\xF5es maiores, expondo-os como bibliotecas C cham\xE1veis de Python, Rust ou qualquer host com FFI."
+    }
+  }
+};
+
 // src/languages/gcode.ts
 var gcode = {
   slug: "gcode",
@@ -4271,7 +4894,7 @@ var gcode = {
     ecosystems: ["CNC machining", "Additive manufacturing"]
   },
   version: "RS-274",
-  logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=G",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_gcode.svg",
   color: "#DC2626",
   i18n: {
     en: {
@@ -4370,7 +4993,7 @@ var gettext = {
     ecosystems: ["Internationalization", "Localization"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=PO",
+  logo: "https://cdn.simpleicons.org/gnu/A42E2B",
   color: "#7C3AED",
   i18n: {
     en: {
@@ -4463,6 +5086,9 @@ var gleam = {
   author: "Louis Pilfold",
   website: "https://gleam.run",
   paradigms: ["functional", "statically typed", "concurrent", "actor-model"],
+  relations: {
+    compilesTo: ["erlang", "javascript"]
+  },
   tooling: {
     runtimes: ["Erlang/OTP", "BEAM", "JavaScript"],
     packageManagers: ["gleam", "Hex"],
@@ -4607,6 +5233,7 @@ var gml = {
 // src/languages/go.ts
 var go = {
   slug: "go",
+  aliases: ["golang"],
   publishedDate: "2012-03-28",
   extensions: [".go"],
   author: "Robert Griesemer, Rob Pike, Ken Thompson / Google",
@@ -4909,8 +5536,11 @@ var hack = {
   publishedDate: "2014-03-20",
   extensions: [".hack", ".hh", ".hhi"],
   author: "Meta",
-  website: "https://docs.hhvm.com/hack/",
+  website: "https://hacklang.org",
   paradigms: ["object-oriented", "functional", "gradually typed", "imperative"],
+  relations: {
+    dialectOf: ["php"]
+  },
   tooling: {
     runtimes: ["HHVM"],
     packageManagers: ["Composer"],
@@ -5161,6 +5791,9 @@ var haxe = {
   author: "Nicolas Cannasse / Haxe Foundation",
   website: "https://haxe.org",
   paradigms: ["object-oriented", "functional", "cross-platform", "statically typed"],
+  relations: {
+    compilesTo: ["javascript", "cpp"]
+  },
   tooling: {
     runtimes: ["JavaScript", "HashLink", "JVM", "C++", "C#", "PHP", "Lua", "Python"],
     packageManagers: ["haxelib"],
@@ -5315,7 +5948,7 @@ var hocon = {
     ecosystems: ["JVM", "Scala", "Akka", "Play Framework", "Configuration"]
   },
   version: "1.4.3",
-  logo: "https://dummyimage.com/32x32/F26822/ffffff.png&text=HC",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/hocon.svg",
   color: "#F26822",
   i18n: {
     en: {
@@ -5656,7 +6289,7 @@ var io = {
     ecosystems: ["Scripting", "Prototype Programming", "Language Exploration"]
   },
   version: "2017.09.06",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Io",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_io.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -5741,6 +6374,55 @@ var isabelle = {
   }
 };
 
+// src/languages/j.ts
+var j = {
+  slug: "j",
+  publishedDate: "1990-01-01",
+  extensions: [".ijs"],
+  author: "Kenneth E. Iverson / Roger Hui",
+  website: "https://www.jsoftware.com",
+  paradigms: ["array", "functional", "tacit"],
+  tooling: {
+    runtimes: ["J Engine"],
+    ecosystems: ["Data Science", "Numerical Computing"]
+  },
+  version: "J9.6",
+  logo: "https://avatars.githubusercontent.com/u/583748?v=4",
+  color: "#9EEDFF",
+  i18n: {
+    en: {
+      name: "J",
+      description: "A terse array language by the creator of APL, using ASCII instead of symbols.",
+      longDescription: "J is an array programming language designed by Kenneth Iverson and Roger Hui as a successor to APL, replacing its special symbol set with ASCII digraphs. Programs compose verbs and adverbs over whole arrays, often in a point-free (tacit) style.\n\nJ excels at statistics, mathematical exploration, and data transformation, packing algorithms into remarkably short expressions. The interpreter, labs, and extensive vocabulary documentation are freely available from Jsoftware."
+    },
+    es: {
+      name: "J",
+      description: "Un lenguaje de arrays conciso del creador de APL, usando ASCII en lugar de s\xEDmbolos.",
+      longDescription: "J es un lenguaje de programaci\xF3n de arrays dise\xF1ado por Kenneth Iverson y Roger Hui como sucesor de APL, reemplazando su juego de s\xEDmbolos especiales por d\xEDgrafos ASCII. Los programas componen verbos y adverbios sobre arrays completos, a menudo en estilo t\xE1cito (point-free).\n\nJ destaca en estad\xEDstica, exploraci\xF3n matem\xE1tica y transformaci\xF3n de datos, condensando algoritmos en expresiones notablemente cortas. El int\xE9rprete, los laboratorios y la extensa documentaci\xF3n de vocabulario est\xE1n disponibles gratuitamente en Jsoftware."
+    },
+    it: {
+      name: "J",
+      description: "Un linguaggio di array conciso del creatore di APL, con ASCII al posto dei simboli.",
+      longDescription: "J \xE8 un linguaggio di programmazione di array progettato da Kenneth Iverson e Roger Hui come successore di APL, sostituendo il suo set di simboli speciali con digrammi ASCII. I programmi compongono verbi e avverbi su interi array, spesso in stile tacito (point-free).\n\nJ eccelle in statistica, esplorazione matematica e trasformazione dei dati, condensando algoritmi in espressioni notevolmente brevi. L'interprete, i laboratori e l'ampia documentazione del vocabolario sono disponibili gratuitamente da Jsoftware."
+    },
+    fr: {
+      name: "J",
+      description: "Un langage de tableaux concis du cr\xE9ateur d'APL, utilisant l'ASCII plut\xF4t que des symboles.",
+      longDescription: "J est un langage de programmation de tableaux con\xE7u par Kenneth Iverson et Roger Hui comme successeur d'APL, rempla\xE7ant son jeu de symboles sp\xE9ciaux par des digrammes ASCII. Les programmes composent des verbes et des adverbes sur des tableaux entiers, souvent dans un style tacite (point-free).\n\nJ excelle en statistique, en exploration math\xE9matique et en transformation de donn\xE9es, condensant les algorithmes en expressions remarquablement courtes. L'interpr\xE9teur, les laboratoires et la vaste documentation du vocabulaire sont disponibles gratuitement chez Jsoftware."
+    },
+    de: {
+      name: "J",
+      description: "Eine knappe Array-Sprache vom Sch\xF6pfer von APL, mit ASCII statt Sonderzeichen.",
+      longDescription: "J ist eine Array-Programmiersprache, die Kenneth Iverson und Roger Hui als Nachfolger von APL entworfen haben; der spezielle Symbolsatz wurde durch ASCII-Digraphen ersetzt. Programme komponieren Verben und Adverbien \xFCber ganze Arrays, oft im punktfreien (taciten) Stil.\n\nJ gl\xE4nzt bei Statistik, mathematischer Exploration und Datentransformation und verdichtet Algorithmen zu bemerkenswert kurzen Ausdr\xFCcken. Interpreter, Labs und die umfangreiche Vokabular-Dokumentation sind bei Jsoftware frei erh\xE4ltlich."
+    },
+    pt: {
+      name: "J",
+      description: "Uma linguagem de arrays concisa do criador do APL, usando ASCII em vez de s\xEDmbolos.",
+      longDescription: "J \xE9 uma linguagem de programa\xE7\xE3o de arrays projetada por Kenneth Iverson e Roger Hui como sucessora do APL, substituindo seu conjunto de s\xEDmbolos especiais por d\xEDgrafos ASCII. Os programas comp\xF5em verbos e adv\xE9rbios sobre arrays inteiros, frequentemente em estilo t\xE1cito (point-free).\n\nJ se destaca em estat\xEDstica, explora\xE7\xE3o matem\xE1tica e transforma\xE7\xE3o de dados, condensando algoritmos em express\xF5es notavelmente curtas. O interpretador, os laborat\xF3rios e a extensa documenta\xE7\xE3o de vocabul\xE1rio est\xE3o dispon\xEDveis gratuitamente na Jsoftware."
+    }
+  }
+};
+
 // src/languages/janet.ts
 var janet = {
   slug: "janet",
@@ -5844,6 +6526,7 @@ var java = {
 // src/languages/javascript.ts
 var javascript = {
   slug: "javascript",
+  aliases: ["js", "ecmascript"],
   publishedDate: "1995-12-04",
   extensions: [".js", ".mjs", ".cjs", ".jsx"],
   author: "Brendan Eich / Netscape",
@@ -5891,6 +6574,55 @@ var javascript = {
   }
 };
 
+// src/languages/jcl.ts
+var jcl = {
+  slug: "jcl",
+  publishedDate: "1964-04-07",
+  extensions: [".jcl"],
+  author: "IBM",
+  website: "https://www.ibm.com/docs/en/zos/3.1.0?topic=zos-mvs-jcl-reference",
+  paradigms: ["declarative", "batch"],
+  tooling: {
+    runtimes: ["z/OS", "MVS", "JES2", "JES3"],
+    ecosystems: ["Mainframe", "Batch Processing"]
+  },
+  version: "z/OS 3.1",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
+  color: "#1F70C1",
+  i18n: {
+    en: {
+      name: "JCL",
+      description: "IBM Job Control Language for describing batch jobs on z/OS mainframes.",
+      longDescription: "JCL (Job Control Language) tells IBM mainframe operating systems how to run batch work: which programs to execute, in what order, with which datasets, and how to react to failures. JOB, EXEC, and DD statements describe jobs, steps, and data allocations processed by the JES2/JES3 subsystems.\n\nIntroduced with System/360 in 1964, JCL still orchestrates nightly batch processing in banking, insurance, and government workloads on z/OS, usually alongside COBOL, PL/I, and REXX."
+    },
+    es: {
+      name: "JCL",
+      description: "El Job Control Language de IBM para describir trabajos batch en mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indica a los sistemas operativos de mainframe de IBM c\xF3mo ejecutar trabajo batch: qu\xE9 programas ejecutar, en qu\xE9 orden, con qu\xE9 datasets y c\xF3mo reaccionar ante fallos. Las sentencias JOB, EXEC y DD describen trabajos, pasos y asignaciones de datos procesados por los subsistemas JES2/JES3.\n\nIntroducido con el System/360 en 1964, JCL sigue orquestando el procesamiento batch nocturno en cargas bancarias, de seguros y gubernamentales sobre z/OS, normalmente junto a COBOL, PL/I y REXX."
+    },
+    it: {
+      name: "JCL",
+      description: "Il Job Control Language di IBM per descrivere job batch sui mainframe z/OS.",
+      longDescription: "JCL (Job Control Language) indica ai sistemi operativi mainframe di IBM come eseguire il lavoro batch: quali programmi eseguire, in quale ordine, con quali dataset e come reagire ai fallimenti. Le istruzioni JOB, EXEC e DD descrivono job, step e allocazioni di dati elaborati dai sottosistemi JES2/JES3.\n\nIntrodotto con il System/360 nel 1964, JCL orchestra ancora l'elaborazione batch notturna nei carichi bancari, assicurativi e governativi su z/OS, di solito insieme a COBOL, PL/I e REXX."
+    },
+    fr: {
+      name: "JCL",
+      description: "Le Job Control Language d'IBM pour d\xE9crire les travaux batch sur mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indique aux syst\xE8mes d'exploitation mainframe d'IBM comment ex\xE9cuter le travail batch : quels programmes lancer, dans quel ordre, avec quels datasets et comment r\xE9agir aux \xE9checs. Les instructions JOB, EXEC et DD d\xE9crivent les travaux, les \xE9tapes et les allocations de donn\xE9es trait\xE9s par les sous-syst\xE8mes JES2/JES3.\n\nIntroduit avec le System/360 en 1964, JCL orchestre encore le traitement batch nocturne des charges bancaires, d'assurance et gouvernementales sous z/OS, g\xE9n\xE9ralement aux c\xF4t\xE9s de COBOL, PL/I et REXX."
+    },
+    de: {
+      name: "JCL",
+      description: "IBMs Job Control Language zur Beschreibung von Batch-Jobs auf z/OS-Mainframes.",
+      longDescription: "JCL (Job Control Language) sagt IBM-Mainframe-Betriebssystemen, wie Batch-Arbeit auszuf\xFChren ist: welche Programme in welcher Reihenfolge laufen, mit welchen Datasets und wie auf Fehler zu reagieren ist. JOB-, EXEC- und DD-Anweisungen beschreiben Jobs, Schritte und Datenzuweisungen, die von den JES2/JES3-Subsystemen verarbeitet werden.\n\nMit dem System/360 im Jahr 1964 eingef\xFChrt, orchestriert JCL noch heute die n\xE4chtliche Batch-Verarbeitung in Bank-, Versicherungs- und Beh\xF6rden-Workloads auf z/OS, \xFCblicherweise neben COBOL, PL/I und REXX."
+    },
+    pt: {
+      name: "JCL",
+      description: "A Job Control Language da IBM para descrever jobs batch em mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) diz aos sistemas operacionais de mainframe da IBM como executar trabalho batch: quais programas executar, em que ordem, com quais datasets e como reagir a falhas. As instru\xE7\xF5es JOB, EXEC e DD descrevem jobs, passos e aloca\xE7\xF5es de dados processados pelos subsistemas JES2/JES3.\n\nIntroduzida com o System/360 em 1964, a JCL ainda orquestra o processamento batch noturno em cargas banc\xE1rias, de seguros e governamentais no z/OS, geralmente ao lado de COBOL, PL/I e REXX."
+    }
+  }
+};
+
 // src/languages/jinja.ts
 var jinja = {
   slug: "jinja",
@@ -5990,15 +6722,64 @@ var jmespath = {
   }
 };
 
-// src/languages/json.ts
-var json = {
-  slug: "json",
-  publishedDate: "2001-04-01",
-  extensions: [".json"],
-  author: "Douglas Crockford",
-  website: "https://www.json.org/json-en.html",
-  paradigms: ["data serialization", "declarative"],
-  version: "RFC 8259",
+// src/languages/jq.ts
+var jq = {
+  slug: "jq",
+  publishedDate: "2012-10-21",
+  extensions: [".jq"],
+  author: "Stephen Dolan",
+  website: "https://jqlang.org",
+  paradigms: ["functional", "declarative", "query"],
+  tooling: {
+    runtimes: ["jq CLI"],
+    ecosystems: ["Data Processing", "DevOps", "Scripting"]
+  },
+  version: "1.8.1",
+  logo: "https://avatars.githubusercontent.com/u/125535133?v=4",
+  color: "#C7254E",
+  i18n: {
+    en: {
+      name: "jq",
+      description: "A functional filter language for slicing, transforming, and querying JSON.",
+      longDescription: "jq is a lightweight command-line language for processing JSON. Programs are written as filter pipelines that select, reshape, and combine values, with built-in functions for iteration, reduction, string handling, and arithmetic.\n\nIt is a staple of shell scripting and DevOps workflows, used to inspect API responses, transform configuration, and glue JSON-producing tools together. Larger filters can be stored in .jq files and reused as modules."
+    },
+    es: {
+      name: "jq",
+      description: "Un lenguaje funcional de filtros para cortar, transformar y consultar JSON.",
+      longDescription: "jq es un lenguaje ligero de l\xEDnea de comandos para procesar JSON. Los programas se escriben como tuber\xEDas de filtros que seleccionan, remodelan y combinan valores, con funciones integradas para iteraci\xF3n, reducci\xF3n, manejo de cadenas y aritm\xE9tica.\n\nEs una pieza b\xE1sica del scripting de shell y de los flujos DevOps, usado para inspeccionar respuestas de API, transformar configuraci\xF3n y conectar herramientas que producen JSON. Los filtros grandes pueden guardarse en archivos .jq y reutilizarse como m\xF3dulos."
+    },
+    it: {
+      name: "jq",
+      description: "Un linguaggio funzionale di filtri per tagliare, trasformare e interrogare JSON.",
+      longDescription: "jq \xE8 un linguaggio leggero da riga di comando per elaborare JSON. I programmi si scrivono come pipeline di filtri che selezionano, rimodellano e combinano valori, con funzioni integrate per iterazione, riduzione, gestione delle stringhe e aritmetica.\n\n\xC8 un elemento fondamentale dello scripting di shell e dei flussi DevOps, usato per ispezionare risposte di API, trasformare configurazioni e collegare strumenti che producono JSON. I filtri pi\xF9 grandi possono essere salvati in file .jq e riutilizzati come moduli."
+    },
+    fr: {
+      name: "jq",
+      description: "Un langage fonctionnel de filtres pour d\xE9couper, transformer et interroger du JSON.",
+      longDescription: "jq est un langage l\xE9ger en ligne de commande pour traiter du JSON. Les programmes s'\xE9crivent comme des pipelines de filtres qui s\xE9lectionnent, remod\xE8lent et combinent des valeurs, avec des fonctions int\xE9gr\xE9es pour l'it\xE9ration, la r\xE9duction, le traitement des cha\xEEnes et l'arithm\xE9tique.\n\nC'est un incontournable des scripts shell et des workflows DevOps, utilis\xE9 pour inspecter des r\xE9ponses d'API, transformer de la configuration et relier des outils produisant du JSON. Les filtres volumineux peuvent \xEAtre stock\xE9s dans des fichiers .jq et r\xE9utilis\xE9s comme modules."
+    },
+    de: {
+      name: "jq",
+      description: "Eine funktionale Filtersprache zum Zerlegen, Transformieren und Abfragen von JSON.",
+      longDescription: "jq ist eine leichtgewichtige Kommandozeilensprache zur Verarbeitung von JSON. Programme werden als Filter-Pipelines geschrieben, die Werte ausw\xE4hlen, umformen und kombinieren, mit eingebauten Funktionen f\xFCr Iteration, Reduktion, Zeichenkettenverarbeitung und Arithmetik.\n\nSie ist ein fester Bestandteil von Shell-Skripten und DevOps-Workflows und dient dazu, API-Antworten zu untersuchen, Konfigurationen zu transformieren und JSON-erzeugende Werkzeuge zu verbinden. Gr\xF6\xDFere Filter k\xF6nnen in .jq-Dateien abgelegt und als Module wiederverwendet werden."
+    },
+    pt: {
+      name: "jq",
+      description: "Uma linguagem funcional de filtros para fatiar, transformar e consultar JSON.",
+      longDescription: "jq \xE9 uma linguagem leve de linha de comando para processar JSON. Os programas s\xE3o escritos como pipelines de filtros que selecionam, remodelam e combinam valores, com fun\xE7\xF5es embutidas para itera\xE7\xE3o, redu\xE7\xE3o, manipula\xE7\xE3o de strings e aritm\xE9tica.\n\n\xC9 um item b\xE1sico do scripting de shell e dos fluxos DevOps, usado para inspecionar respostas de API, transformar configura\xE7\xF5es e conectar ferramentas que produzem JSON. Filtros maiores podem ser guardados em arquivos .jq e reutilizados como m\xF3dulos."
+    }
+  }
+};
+
+// src/languages/json.ts
+var json = {
+  slug: "json",
+  publishedDate: "2001-04-01",
+  extensions: [".json"],
+  author: "Douglas Crockford",
+  website: "https://www.json.org/json-en.html",
+  paradigms: ["data serialization", "declarative"],
+  version: "RFC 8259",
   logo: "https://www.json.org/img/json160.gif",
   color: "#000000",
   i18n: {
@@ -6043,6 +6824,9 @@ var json5 = {
   author: "Aseem Kishore",
   website: "https://json5.org",
   paradigms: ["declarative"],
+  relations: {
+    supersetOf: ["json"]
+  },
   tooling: {
     runtimes: ["Node.js", "Browser"],
     packageManagers: ["npm", "pnpm", "Yarn"],
@@ -6142,6 +6926,9 @@ var jsonc = {
   author: "Microsoft",
   website: "https://jsonc.org",
   paradigms: ["data serialization", "configuration"],
+  relations: {
+    supersetOf: ["json"]
+  },
   tooling: {
     runtimes: ["Editors", "Build tools"],
     ecosystems: ["JavaScript", "TypeScript", "Configuration"]
@@ -6535,6 +7322,7 @@ var koka = {
 // src/languages/kotlin.ts
 var kotlin = {
   slug: "kotlin",
+  aliases: ["kt"],
   publishedDate: "2016-02-15",
   extensions: [".kt", ".kts"],
   author: "JetBrains",
@@ -6689,6 +7477,10 @@ var less = {
   author: "Alexis Sellier / Less Core Team",
   website: "https://lesscss.org",
   paradigms: ["declarative", "stylesheet", "preprocessor"],
+  relations: {
+    dialectOf: ["css"],
+    compilesTo: ["css"]
+  },
   tooling: {
     runtimes: ["Less.js", "Node.js", "Browser"],
     packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
@@ -6731,6 +7523,56 @@ var less = {
   }
 };
 
+// src/languages/lex.ts
+var lex = {
+  slug: "lex",
+  aliases: ["flex"],
+  publishedDate: "1975-07-01",
+  extensions: [".l", ".lex"],
+  author: "Mike Lesk / Eric Schmidt (Bell Labs)",
+  website: "https://pubs.opengroup.org/onlinepubs/9699919799/utilities/lex.html",
+  paradigms: ["declarative", "generator"],
+  tooling: {
+    runtimes: ["C toolchains"],
+    ecosystems: ["Compilers", "Language Tooling", "Unix"]
+  },
+  version: "POSIX lex / flex 2.6.4",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/lex.svg",
+  color: "#DBCA00",
+  i18n: {
+    en: {
+      name: "Lex",
+      description: "A lexical analyzer generator that turns regex rules into scanner code.",
+      longDescription: "Lex is a classic Unix tool that generates lexical analyzers. A .l specification pairs regular expressions with C actions; the generated scanner reads input, groups characters into tokens, and hands them to a parser, typically one produced by Yacc or Bison.\n\nThe modern open-source implementation is flex, which remains a standard part of compiler courses and production language tooling wherever hand-written lexers are not required."
+    },
+    es: {
+      name: "Lex",
+      description: "Un generador de analizadores l\xE9xicos que convierte reglas regex en c\xF3digo de escaneo.",
+      longDescription: "Lex es una herramienta cl\xE1sica de Unix que genera analizadores l\xE9xicos. Una especificaci\xF3n .l empareja expresiones regulares con acciones en C; el esc\xE1ner generado lee la entrada, agrupa caracteres en tokens y los entrega a un parser, normalmente producido por Yacc o Bison.\n\nLa implementaci\xF3n moderna de c\xF3digo abierto es flex, que sigue siendo parte est\xE1ndar de los cursos de compiladores y de las herramientas de lenguajes en producci\xF3n donde no se requieren lexers escritos a mano."
+    },
+    it: {
+      name: "Lex",
+      description: "Un generatore di analizzatori lessicali che trasforma regole regex in codice scanner.",
+      longDescription: "Lex \xE8 uno strumento classico di Unix che genera analizzatori lessicali. Una specifica .l abbina espressioni regolari ad azioni in C; lo scanner generato legge l'input, raggruppa i caratteri in token e li passa a un parser, tipicamente prodotto da Yacc o Bison.\n\nL'implementazione open source moderna \xE8 flex, che rimane una parte standard dei corsi sui compilatori e degli strumenti linguistici in produzione dove non servono lexer scritti a mano."
+    },
+    fr: {
+      name: "Lex",
+      description: "Un g\xE9n\xE9rateur d'analyseurs lexicaux qui transforme des r\xE8gles regex en code de scanner.",
+      longDescription: "Lex est un outil Unix classique qui g\xE9n\xE8re des analyseurs lexicaux. Une sp\xE9cification .l associe des expressions r\xE9guli\xE8res \xE0 des actions en C ; le scanner g\xE9n\xE9r\xE9 lit l'entr\xE9e, regroupe les caract\xE8res en jetons et les transmet \xE0 un parseur, g\xE9n\xE9ralement produit par Yacc ou Bison.\n\nL'impl\xE9mentation open source moderne est flex, qui reste un \xE9l\xE9ment standard des cours de compilation et de l'outillage de langages en production lorsque des lexers \xE9crits \xE0 la main ne sont pas n\xE9cessaires."
+    },
+    de: {
+      name: "Lex",
+      description: "Ein Generator f\xFCr lexikalische Analysatoren, der Regex-Regeln in Scanner-Code \xFCbersetzt.",
+      longDescription: "Lex ist ein klassisches Unix-Werkzeug zur Erzeugung lexikalischer Analysatoren. Eine .l-Spezifikation verkn\xFCpft regul\xE4re Ausdr\xFCcke mit C-Aktionen; der erzeugte Scanner liest die Eingabe, gruppiert Zeichen zu Tokens und \xFCbergibt sie an einen Parser, der typischerweise von Yacc oder Bison erzeugt wird.\n\nDie moderne Open-Source-Implementierung ist flex, die weiterhin fester Bestandteil von Compiler-Kursen und produktivem Sprach-Tooling ist, wo keine handgeschriebenen Lexer erforderlich sind."
+    },
+    pt: {
+      name: "Lex",
+      description: "Um gerador de analisadores l\xE9xicos que converte regras regex em c\xF3digo de scanner.",
+      longDescription: "Lex \xE9 uma ferramenta cl\xE1ssica do Unix que gera analisadores l\xE9xicos. Uma especifica\xE7\xE3o .l combina express\xF5es regulares com a\xE7\xF5es em C; o scanner gerado l\xEA a entrada, agrupa caracteres em tokens e os entrega a um parser, normalmente produzido pelo Yacc ou Bison.\n\nA implementa\xE7\xE3o moderna de c\xF3digo aberto \xE9 o flex, que continua sendo parte padr\xE3o dos cursos de compiladores e das ferramentas de linguagens em produ\xE7\xE3o onde lexers escritos \xE0 m\xE3o n\xE3o s\xE3o necess\xE1rios."
+    }
+  }
+};
+
 // src/languages/ligo.ts
 var ligo = {
   slug: "ligo",
@@ -6794,7 +7636,7 @@ var linkerscript = {
     ecosystems: ["Embedded systems", "Operating systems"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/475569/ffffff.png&text=LD",
+  logo: "https://cdn.simpleicons.org/gnu/A42E2B",
   color: "#475569",
   i18n: {
     en: {
@@ -6993,7 +7835,7 @@ var lobster = {
     ecosystems: ["Games", "Interactive Graphics", "Language Experiments"]
   },
   version: "development snapshot",
-  logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=Lo",
+  logo: "https://raw.githubusercontent.com/aardappel/lobster/master/docs/lobster.png",
   color: "#DC2626",
   i18n: {
     en: {
@@ -7136,6 +7978,9 @@ var luau = {
   author: "Roblox",
   website: "https://luau.org",
   paradigms: ["imperative", "scripting", "gradually typed", "embeddable"],
+  relations: {
+    supersetOf: ["lua"]
+  },
   tooling: {
     runtimes: ["Luau VM", "Roblox"],
     packageManagers: ["Wally", "Pesde"],
@@ -7280,6 +8125,7 @@ var mako = {
 // src/languages/markdown.ts
 var markdown = {
   slug: "markdown",
+  aliases: ["md"],
   publishedDate: "2004-03-19",
   extensions: [".md", ".markdown", ".mdown", ".mkd"],
   author: "John Gruber / Aaron Swartz",
@@ -7527,6 +8373,9 @@ var mdx = {
   author: "MDX contributors",
   website: "https://mdxjs.com",
   paradigms: ["markup", "component-oriented", "declarative", "documentation"],
+  relations: {
+    supersetOf: ["markdown"]
+  },
   tooling: {
     runtimes: ["React", "Node.js"],
     packageManagers: ["npm", "Yarn", "pnpm"],
@@ -7830,7 +8679,7 @@ var modula2 = {
     ecosystems: ["Systems Programming", "Education", "Language History"]
   },
   version: "ISO/IEC 10514-1:1996",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=M2",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/modula-2.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -8316,6 +9165,9 @@ var nim = {
   author: "Andreas Rumpf",
   website: "https://nim-lang.org",
   paradigms: ["systems", "imperative", "functional", "metaprogramming", "statically typed"],
+  relations: {
+    compilesTo: ["c", "javascript"]
+  },
   tooling: {
     runtimes: ["Native", "JavaScript"],
     packageManagers: ["Nimble"],
@@ -8408,6 +9260,57 @@ var nix = {
   }
 };
 
+// src/languages/noir.ts
+var noir = {
+  slug: "noir",
+  status: "experimental",
+  publishedDate: "2022-01-01",
+  extensions: [".nr"],
+  author: "Aztec Labs",
+  website: "https://noir-lang.org",
+  paradigms: ["imperative", "declarative", "zero-knowledge"],
+  tooling: {
+    runtimes: ["ACVM"],
+    packageManagers: ["Nargo"],
+    ecosystems: ["Blockchain", "Cryptography", "Web3"]
+  },
+  version: "1.0.0-beta",
+  logo: "https://avatars.githubusercontent.com/u/72610319?v=4",
+  color: "#2F1F49",
+  i18n: {
+    en: {
+      name: "Noir",
+      description: "A Rust-like language for writing zero-knowledge proof circuits.",
+      longDescription: "Noir is a domain-specific language for writing zero-knowledge circuits, developed by Aztec Labs. Programs written in Rust-like syntax compile to an intermediate representation (ACIR) that can target multiple proving backends, abstracting away the cryptographic machinery of ZK-SNARKs.\n\nWith the Nargo toolchain for building, testing, and proving, Noir is used for private smart contracts, identity proofs, and verifiable computation across the zero-knowledge ecosystem."
+    },
+    es: {
+      name: "Noir",
+      description: "Un lenguaje similar a Rust para escribir circuitos de pruebas de conocimiento cero.",
+      longDescription: "Noir es un lenguaje de dominio espec\xEDfico para escribir circuitos de conocimiento cero, desarrollado por Aztec Labs. Los programas, con sintaxis similar a Rust, compilan a una representaci\xF3n intermedia (ACIR) que puede apuntar a m\xFAltiples backends de prueba, abstrayendo la maquinaria criptogr\xE1fica de los ZK-SNARKs.\n\nCon la cadena de herramientas Nargo para compilar, probar y generar pruebas, Noir se usa en contratos inteligentes privados, pruebas de identidad y computaci\xF3n verificable en el ecosistema de conocimiento cero."
+    },
+    it: {
+      name: "Noir",
+      description: "Un linguaggio simile a Rust per scrivere circuiti a conoscenza zero.",
+      longDescription: "Noir \xE8 un linguaggio di dominio specifico per scrivere circuiti a conoscenza zero, sviluppato da Aztec Labs. I programmi, con sintassi simile a Rust, compilano in una rappresentazione intermedia (ACIR) che pu\xF2 puntare a pi\xF9 backend di prova, astraendo la macchina crittografica degli ZK-SNARK.\n\nCon la toolchain Nargo per compilare, testare e generare prove, Noir \xE8 usato per smart contract privati, prove di identit\xE0 e computazione verificabile in tutto l'ecosistema a conoscenza zero."
+    },
+    fr: {
+      name: "Noir",
+      description: "Un langage proche de Rust pour \xE9crire des circuits \xE0 divulgation nulle de connaissance.",
+      longDescription: "Noir est un langage d\xE9di\xE9 \xE0 l'\xE9criture de circuits \xE0 divulgation nulle de connaissance, d\xE9velopp\xE9 par Aztec Labs. Les programmes, \xE0 la syntaxe proche de Rust, compilent vers une repr\xE9sentation interm\xE9diaire (ACIR) capable de cibler plusieurs backends de preuve, en masquant la machinerie cryptographique des ZK-SNARKs.\n\nAvec la cha\xEEne d'outils Nargo pour compiler, tester et prouver, Noir sert aux contrats intelligents priv\xE9s, aux preuves d'identit\xE9 et au calcul v\xE9rifiable dans l'\xE9cosyst\xE8me zero-knowledge."
+    },
+    de: {
+      name: "Noir",
+      description: "Eine Rust-\xE4hnliche Sprache zum Schreiben von Zero-Knowledge-Beweis-Schaltkreisen.",
+      longDescription: "Noir ist eine dom\xE4nenspezifische Sprache zum Schreiben von Zero-Knowledge-Schaltkreisen, entwickelt von Aztec Labs. Programme in Rust-\xE4hnlicher Syntax kompilieren zu einer Zwischendarstellung (ACIR), die mehrere Proving-Backends ansteuern kann und die kryptografische Maschinerie von ZK-SNARKs abstrahiert.\n\nMit der Nargo-Toolchain zum Bauen, Testen und Beweisen wird Noir f\xFCr private Smart Contracts, Identit\xE4tsnachweise und verifizierbare Berechnungen im Zero-Knowledge-\xD6kosystem eingesetzt."
+    },
+    pt: {
+      name: "Noir",
+      description: "Uma linguagem parecida com Rust para escrever circuitos de conhecimento zero.",
+      longDescription: "Noir \xE9 uma linguagem de dom\xEDnio espec\xEDfico para escrever circuitos de conhecimento zero, desenvolvida pela Aztec Labs. Os programas, com sintaxe parecida com Rust, compilam para uma representa\xE7\xE3o intermedi\xE1ria (ACIR) que pode mirar v\xE1rios backends de prova, abstraindo a maquinaria criptogr\xE1fica dos ZK-SNARKs.\n\nCom a toolchain Nargo para compilar, testar e provar, o Noir \xE9 usado em contratos inteligentes privados, provas de identidade e computa\xE7\xE3o verific\xE1vel em todo o ecossistema de conhecimento zero."
+    }
+  }
+};
+
 // src/languages/nunjucks.ts
 var nunjucks = {
   slug: "nunjucks",
@@ -8471,7 +9374,7 @@ var nushell = {
     packageManagers: ["nupm"],
     ecosystems: ["Shell", "Unix", "Windows", "macOS"]
   },
-  version: "0.114.0",
+  version: "0.114.1",
   logo: "https://cdn.simpleicons.org/nushell/3AA675",
   color: "#3AA675",
   i18n: {
@@ -8521,7 +9424,7 @@ var oberon = {
     ecosystems: ["Operating Systems", "Education", "Language Design"]
   },
   version: "Oberon-2",
-  logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Ob",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/oberon.svg",
   color: "#0F766E",
   i18n: {
     en: {
@@ -8560,11 +9463,15 @@ var oberon = {
 // src/languages/objective-c.ts
 var objectiveC = {
   slug: "objective-c",
+  aliases: ["objc", "objective c"],
   publishedDate: "1984-01-01",
   extensions: [".m", ".mm"],
   author: "Brad Cox / Tom Love",
   website: "https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/",
   paradigms: ["class-based", "dynamic", "object-oriented", "reflective"],
+  relations: {
+    supersetOf: ["c"]
+  },
   tooling: {
     runtimes: ["Objective-C runtime", "Apple platforms", "GNUstep"],
     packageManagers: ["CocoaPods", "Swift Package Manager"],
@@ -9214,7 +10121,7 @@ var plI = {
     ecosystems: ["Mainframe", "Enterprise", "Scientific Computing"]
   },
   version: "Enterprise PL/I 6.2",
-  logo: "https://dummyimage.com/32x32/1F2937/ffffff.png&text=PL1",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
   color: "#1F2937",
   i18n: {
     en: {
@@ -9308,6 +10215,9 @@ var plpgsql = {
   author: "PostgreSQL Global Development Group",
   website: "https://www.postgresql.org/docs/current/plpgsql.html",
   paradigms: ["procedural", "database"],
+  relations: {
+    dialectOf: ["sql"]
+  },
   tooling: {
     runtimes: ["PostgreSQL"],
     ecosystems: ["Relational databases", "Stored procedures"]
@@ -9357,6 +10267,9 @@ var plsql = {
   author: "Oracle",
   website: "https://www.oracle.com/database/technologies/appdev/plsql.html",
   paradigms: ["procedural", "database", "declarative", "imperative"],
+  relations: {
+    dialectOf: ["sql"]
+  },
   tooling: {
     runtimes: ["Oracle Database"],
     ecosystems: ["Oracle", "SQL", "Enterprise Data"]
@@ -9509,7 +10422,7 @@ var postscript = {
     ecosystems: ["Print", "PDF"]
   },
   version: "PostScript 3",
-  logo: "https://dummyimage.com/32x32/EC1C24/ffffff.png&text=PS",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_postscript.svg",
   color: "#EC1C24",
   i18n: {
     en: {
@@ -9557,7 +10470,7 @@ var powerquery = {
     ecosystems: ["Microsoft Power BI", "Excel", "Azure Data Factory", "Microsoft Fabric"]
   },
   version: "Power Query M 2025",
-  logo: "https://dummyimage.com/32x32/F2C811/000000.png&text=PQ",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/c/cf/New_Power_BI_Logo.svg",
   color: "#F2C811",
   i18n: {
     en: {
@@ -9596,6 +10509,7 @@ var powerquery = {
 // src/languages/powershell.ts
 var powershell = {
   slug: "powershell",
+  aliases: ["pwsh"],
   publishedDate: "2006-11-14",
   extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"],
   author: "Microsoft",
@@ -9791,9 +10705,60 @@ var promql = {
   }
 };
 
+// src/languages/properties.ts
+var properties = {
+  slug: "properties",
+  aliases: ["java properties"],
+  publishedDate: "1996-01-23",
+  extensions: [".properties"],
+  author: "Sun Microsystems",
+  website: "https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html",
+  paradigms: ["declarative", "configuration"],
+  tooling: {
+    runtimes: ["JVM"],
+    ecosystems: ["JVM", "Configuration"]
+  },
+  version: "stable",
+  logo: "https://cdn.simpleicons.org/openjdk/437291",
+  color: "#2A6277",
+  i18n: {
+    en: {
+      name: "Java Properties",
+      description: "A simple key-value configuration format used across the Java ecosystem.",
+      longDescription: "Java Properties files store configuration as key-value pairs in plain text, with support for comments, escaping, and Unicode sequences. The format ships with the JDK through java.util.Properties and dates back to Java 1.0.\n\nIt remains the default configuration format across the JVM ecosystem: Spring application settings, Gradle project configuration, log4j setup, and resource bundles for internationalization all commonly live in .properties files."
+    },
+    es: {
+      name: "Java Properties",
+      description: "Un formato simple de configuraci\xF3n clave-valor usado en todo el ecosistema Java.",
+      longDescription: "Los archivos Java Properties almacenan configuraci\xF3n como pares clave-valor en texto plano, con soporte para comentarios, escapes y secuencias Unicode. El formato viene con el JDK a trav\xE9s de java.util.Properties y se remonta a Java 1.0.\n\nSigue siendo el formato de configuraci\xF3n por defecto en el ecosistema JVM: los ajustes de aplicaciones Spring, la configuraci\xF3n de proyectos Gradle, la configuraci\xF3n de log4j y los resource bundles de internacionalizaci\xF3n suelen vivir en archivos .properties."
+    },
+    it: {
+      name: "Java Properties",
+      description: "Un semplice formato di configurazione chiave-valore usato nell'ecosistema Java.",
+      longDescription: "I file Java Properties memorizzano la configurazione come coppie chiave-valore in testo semplice, con supporto per commenti, escape e sequenze Unicode. Il formato \xE8 incluso nel JDK tramite java.util.Properties e risale a Java 1.0.\n\nRimane il formato di configurazione predefinito nell'ecosistema JVM: le impostazioni delle applicazioni Spring, la configurazione dei progetti Gradle, la configurazione di log4j e i resource bundle per l'internazionalizzazione vivono comunemente in file .properties."
+    },
+    fr: {
+      name: "Java Properties",
+      description: "Un format simple de configuration cl\xE9-valeur utilis\xE9 dans tout l'\xE9cosyst\xE8me Java.",
+      longDescription: "Les fichiers Java Properties stockent la configuration sous forme de paires cl\xE9-valeur en texte brut, avec la prise en charge des commentaires, de l'\xE9chappement et des s\xE9quences Unicode. Le format est livr\xE9 avec le JDK via java.util.Properties et remonte \xE0 Java 1.0.\n\nIl reste le format de configuration par d\xE9faut de l'\xE9cosyst\xE8me JVM : les param\xE8tres d'applications Spring, la configuration de projets Gradle, la configuration de log4j et les resource bundles d'internationalisation vivent couramment dans des fichiers .properties."
+    },
+    de: {
+      name: "Java Properties",
+      description: "Ein einfaches Schl\xFCssel-Wert-Konfigurationsformat aus dem Java-\xD6kosystem.",
+      longDescription: "Java-Properties-Dateien speichern Konfiguration als Schl\xFCssel-Wert-Paare im Klartext, mit Unterst\xFCtzung f\xFCr Kommentare, Escaping und Unicode-Sequenzen. Das Format ist \xFCber java.util.Properties Teil des JDK und stammt aus Java 1.0.\n\nEs bleibt das Standard-Konfigurationsformat im JVM-\xD6kosystem: Spring-Anwendungseinstellungen, Gradle-Projektkonfiguration, log4j-Setup und Resource-Bundles f\xFCr Internationalisierung liegen \xFCblicherweise in .properties-Dateien."
+    },
+    pt: {
+      name: "Java Properties",
+      description: "Um formato simples de configura\xE7\xE3o chave-valor usado em todo o ecossistema Java.",
+      longDescription: "Os arquivos Java Properties armazenam configura\xE7\xE3o como pares chave-valor em texto simples, com suporte a coment\xE1rios, escapes e sequ\xEAncias Unicode. O formato acompanha o JDK por meio de java.util.Properties e remonta ao Java 1.0.\n\nContinua sendo o formato de configura\xE7\xE3o padr\xE3o do ecossistema JVM: as configura\xE7\xF5es de aplica\xE7\xF5es Spring, a configura\xE7\xE3o de projetos Gradle, a configura\xE7\xE3o do log4j e os resource bundles de internacionaliza\xE7\xE3o costumam viver em arquivos .properties."
+    }
+  }
+};
+
 // src/languages/protobuf.ts
 var protobuf = {
   slug: "protobuf",
+  aliases: ["proto", "protocol buffers"],
   publishedDate: "2008-07-07",
   extensions: [".proto"],
   author: "Google",
@@ -9841,6 +10806,59 @@ var protobuf = {
   }
 };
 
+// src/languages/prql.ts
+var prql = {
+  slug: "prql",
+  status: "experimental",
+  publishedDate: "2022-01-24",
+  extensions: [".prql"],
+  author: "PRQL project",
+  website: "https://prql-lang.org",
+  paradigms: ["declarative", "functional", "query"],
+  relations: {
+    compilesTo: ["sql"]
+  },
+  tooling: {
+    runtimes: ["prqlc"],
+    ecosystems: ["Databases", "Data Processing"]
+  },
+  version: "0.13.0",
+  logo: "https://avatars.githubusercontent.com/u/102252800?v=4",
+  color: "#4A6FBF",
+  i18n: {
+    en: {
+      name: "PRQL",
+      description: "A pipelined relational query language that compiles to readable SQL.",
+      longDescription: "PRQL (Pipelined Relational Query Language) reimagines SQL as a series of transformations: each line filters, derives, aggregates, or sorts the result of the previous one, with variables, functions, and consistent syntax replacing SQL's irregularities.\n\nThe prqlc compiler emits standard SQL for many dialects \u2014 PostgreSQL, DuckDB, SQLite, MySQL, and more \u2014 so PRQL works with existing databases and integrates into Python, Rust, JavaScript, and dbt workflows."
+    },
+    es: {
+      name: "PRQL",
+      description: "Un lenguaje de consultas relacional en tuber\xEDas que compila a SQL legible.",
+      longDescription: "PRQL (Pipelined Relational Query Language) reimagina SQL como una serie de transformaciones: cada l\xEDnea filtra, deriva, agrega u ordena el resultado de la anterior, con variables, funciones y una sintaxis consistente que reemplaza las irregularidades de SQL.\n\nEl compilador prqlc emite SQL est\xE1ndar para muchos dialectos \u2014 PostgreSQL, DuckDB, SQLite, MySQL y m\xE1s \u2014 de modo que PRQL funciona con bases de datos existentes y se integra en flujos de Python, Rust, JavaScript y dbt."
+    },
+    it: {
+      name: "PRQL",
+      description: "Un linguaggio di query relazionale a pipeline che compila in SQL leggibile.",
+      longDescription: "PRQL (Pipelined Relational Query Language) reimmagina SQL come una serie di trasformazioni: ogni riga filtra, deriva, aggrega oppure ordina il risultato della precedente, con variabili, funzioni e una sintassi coerente al posto delle irregolarit\xE0 di SQL.\n\nIl compilatore prqlc emette SQL standard per molti dialetti \u2014 PostgreSQL, DuckDB, SQLite, MySQL e altri \u2014 quindi PRQL funziona con i database esistenti e si integra nei flussi Python, Rust, JavaScript e dbt."
+    },
+    fr: {
+      name: "PRQL",
+      description: "Un langage de requ\xEAte relationnel en pipeline qui compile vers du SQL lisible.",
+      longDescription: "PRQL (Pipelined Relational Query Language) r\xE9invente SQL comme une s\xE9rie de transformations : chaque ligne filtre, d\xE9rive, agr\xE8ge ou trie le r\xE9sultat de la pr\xE9c\xE9dente, avec des variables, des fonctions et une syntaxe coh\xE9rente rempla\xE7ant les irr\xE9gularit\xE9s de SQL.\n\nLe compilateur prqlc \xE9met du SQL standard pour de nombreux dialectes \u2014 PostgreSQL, DuckDB, SQLite, MySQL et plus \u2014 de sorte que PRQL fonctionne avec les bases existantes et s'int\xE8gre aux flux Python, Rust, JavaScript et dbt."
+    },
+    de: {
+      name: "PRQL",
+      description: "Eine relationale Pipeline-Abfragesprache, die zu lesbarem SQL kompiliert.",
+      longDescription: "PRQL (Pipelined Relational Query Language) denkt SQL als Folge von Transformationen neu: Jede Zeile filtert, leitet ab, aggregiert oder sortiert das Ergebnis der vorherigen, mit Variablen, Funktionen und konsistenter Syntax anstelle der Unregelm\xE4\xDFigkeiten von SQL.\n\nDer prqlc-Compiler erzeugt Standard-SQL f\xFCr viele Dialekte \u2014 PostgreSQL, DuckDB, SQLite, MySQL und mehr \u2014, sodass PRQL mit bestehenden Datenbanken funktioniert und sich in Python-, Rust-, JavaScript- und dbt-Workflows integriert."
+    },
+    pt: {
+      name: "PRQL",
+      description: "Uma linguagem de consulta relacional em pipeline que compila para SQL leg\xEDvel.",
+      longDescription: "PRQL (Pipelined Relational Query Language) reimagina o SQL como uma s\xE9rie de transforma\xE7\xF5es: cada linha filtra, deriva, agrega ou ordena o resultado da anterior, com vari\xE1veis, fun\xE7\xF5es e sintaxe consistente no lugar das irregularidades do SQL.\n\nO compilador prqlc emite SQL padr\xE3o para muitos dialetos \u2014 PostgreSQL, DuckDB, SQLite, MySQL e mais \u2014 de modo que o PRQL funciona com bancos existentes e se integra a fluxos Python, Rust, JavaScript e dbt."
+    }
+  }
+};
+
 // src/languages/pug.ts
 var pug = {
   slug: "pug",
@@ -9949,6 +10967,9 @@ var purescript = {
   author: "Phil Freeman / PureScript contributors",
   website: "https://www.purescript.org",
   paradigms: ["functional", "pure", "statically typed", "declarative"],
+  relations: {
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["JavaScript", "Node.js"],
     packageManagers: ["Spago", "npm"],
@@ -9994,6 +11015,7 @@ var purescript = {
 // src/languages/python.ts
 var python = {
   slug: "python",
+  aliases: ["py"],
   publishedDate: "1991-02-20",
   extensions: [".py", ".pyw"],
   author: "Guido van Rossum",
@@ -10041,6 +11063,56 @@ var python = {
   }
 };
 
+// src/languages/q.ts
+var q = {
+  slug: "q",
+  aliases: ["kdb", "kdb+"],
+  publishedDate: "2003-01-01",
+  extensions: [".q", ".k"],
+  author: "Arthur Whitney / Kx Systems",
+  website: "https://kx.com",
+  paradigms: ["array", "functional", "query"],
+  tooling: {
+    runtimes: ["kdb+"],
+    ecosystems: ["Finance", "Data Science", "Time Series"]
+  },
+  version: "q 4.1",
+  logo: "https://avatars.githubusercontent.com/u/11446750?v=4",
+  color: "#0040CD",
+  i18n: {
+    en: {
+      name: "q / kdb+",
+      description: "An array and query language built into the kdb+ time-series database.",
+      longDescription: "q is the programming and query language of kdb+, the columnar time-series database from Kx Systems. Descended from APL and K, it operates on whole vectors and tables with an extremely terse syntax and treats queries, analytics, and stored procedures as one language.\n\nq/kdb+ dominates tick-data capture and real-time analytics in investment banks, hedge funds, and exchanges, where its in-memory column store processes billions of records with low latency."
+    },
+    es: {
+      name: "q / kdb+",
+      description: "Un lenguaje de arrays y consultas integrado en la base de datos de series temporales kdb+.",
+      longDescription: "q es el lenguaje de programaci\xF3n y consulta de kdb+, la base de datos columnar de series temporales de Kx Systems. Descendiente de APL y K, opera sobre vectores y tablas completas con una sintaxis extremadamente concisa y trata consultas, anal\xEDtica y procedimientos almacenados como un solo lenguaje.\n\nq/kdb+ domina la captura de datos de tick y la anal\xEDtica en tiempo real en bancos de inversi\xF3n, hedge funds y bolsas, donde su almac\xE9n columnar en memoria procesa miles de millones de registros con baja latencia."
+    },
+    it: {
+      name: "q / kdb+",
+      description: "Un linguaggio di array e query integrato nel database di serie temporali kdb+.",
+      longDescription: "q \xE8 il linguaggio di programmazione e interrogazione di kdb+, il database colonnare di serie temporali di Kx Systems. Discendente di APL e K, opera su vettori e tabelle interi con una sintassi estremamente concisa e tratta query, analisi e stored procedure come un unico linguaggio.\n\nq/kdb+ domina la cattura dei dati tick e le analisi in tempo reale in banche di investimento, hedge fund e borse, dove il suo archivio colonnare in memoria elabora miliardi di record a bassa latenza."
+    },
+    fr: {
+      name: "q / kdb+",
+      description: "Un langage de tableaux et de requ\xEAtes int\xE9gr\xE9 \xE0 la base de s\xE9ries temporelles kdb+.",
+      longDescription: "q est le langage de programmation et de requ\xEAte de kdb+, la base de donn\xE9es colonne de s\xE9ries temporelles de Kx Systems. Descendant d'APL et de K, il op\xE8re sur des vecteurs et des tables entiers avec une syntaxe extr\xEAmement concise et traite requ\xEAtes, analyses et proc\xE9dures stock\xE9es comme un seul langage.\n\nq/kdb+ domine la capture de donn\xE9es tick et l'analytique temps r\xE9el dans les banques d'investissement, les hedge funds et les bourses, o\xF9 son stockage colonne en m\xE9moire traite des milliards d'enregistrements \xE0 faible latence."
+    },
+    de: {
+      name: "q / kdb+",
+      description: "Eine Array- und Abfragesprache, eingebaut in die Zeitreihen-Datenbank kdb+.",
+      longDescription: "q ist die Programmier- und Abfragesprache von kdb+, der spaltenorientierten Zeitreihen-Datenbank von Kx Systems. Als Nachfahre von APL und K arbeitet sie auf ganzen Vektoren und Tabellen mit extrem knapper Syntax und behandelt Abfragen, Analysen und Stored Procedures als eine Sprache.\n\nq/kdb+ dominiert die Tick-Daten-Erfassung und Echtzeit-Analytik in Investmentbanken, Hedgefonds und B\xF6rsen, wo der spaltenorientierte In-Memory-Speicher Milliarden von Datens\xE4tzen mit geringer Latenz verarbeitet."
+    },
+    pt: {
+      name: "q / kdb+",
+      description: "Uma linguagem de arrays e consultas embutida no banco de s\xE9ries temporais kdb+.",
+      longDescription: "q \xE9 a linguagem de programa\xE7\xE3o e consulta do kdb+, o banco de dados colunar de s\xE9ries temporais da Kx Systems. Descendente de APL e K, opera sobre vetores e tabelas inteiros com uma sintaxe extremamente concisa e trata consultas, an\xE1lises e stored procedures como uma \xFAnica linguagem.\n\nq/kdb+ domina a captura de dados de tick e a an\xE1lise em tempo real em bancos de investimento, fundos de hedge e bolsas, onde seu armazenamento colunar em mem\xF3ria processa bilh\xF5es de registros com baixa lat\xEAncia."
+    }
+  }
+};
+
 // src/languages/qmake.ts
 var qmake = {
   slug: "qmake",
@@ -10293,6 +11365,7 @@ var racket = {
 // src/languages/raku.ts
 var raku = {
   slug: "raku",
+  aliases: ["perl6", "perl 6"],
   publishedDate: "2015-12-25",
   extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"],
   author: "Raku Community",
@@ -10398,6 +11471,9 @@ var reasonml = {
   author: "Jordan Walke / Reason contributors",
   website: "https://reasonml.github.io",
   paradigms: ["functional", "statically typed", "multi-paradigm"],
+  relations: {
+    compilesTo: ["javascript", "ocaml"]
+  },
   tooling: {
     runtimes: ["OCaml", "JavaScript"],
     packageManagers: ["opam", "npm"],
@@ -10588,6 +11664,56 @@ var rego = {
   }
 };
 
+// src/languages/renpy.ts
+var renpy = {
+  slug: "renpy",
+  aliases: ["ren'py"],
+  publishedDate: "2004-08-24",
+  extensions: [".rpy", ".rpym"],
+  author: "Tom Rothamel",
+  website: "https://www.renpy.org",
+  paradigms: ["imperative", "scripting", "narrative"],
+  tooling: {
+    runtimes: ["Ren'Py Engine", "CPython"],
+    ecosystems: ["Game Development", "Interactive Fiction"]
+  },
+  version: "8.3.7",
+  logo: "https://avatars.githubusercontent.com/u/1900740?v=4",
+  color: "#FF7F7F",
+  i18n: {
+    en: {
+      name: "Ren'Py",
+      description: "A visual novel engine with a screenplay-like script language embedding Python.",
+      longDescription: "Ren'Py is an open-source engine for visual novels and story-driven games. Its script language reads like a screenplay \u2014 labels, dialogue, menus, and scene statements \u2014 while full Python can be embedded anywhere game logic needs it.\n\nThousands of commercial and free titles ship on Ren'Py, which exports to Windows, macOS, Linux, Android, iOS, and the web, and includes built-in support for saves, rollback, localization, and accessibility."
+    },
+    es: {
+      name: "Ren'Py",
+      description: "Un motor de novelas visuales con un lenguaje de guion tipo cinematogr\xE1fico que embebe Python.",
+      longDescription: "Ren'Py es un motor de c\xF3digo abierto para novelas visuales y juegos narrativos. Su lenguaje de script se lee como un guion \u2014 etiquetas, di\xE1logo, men\xFAs y sentencias de escena \u2014 mientras que Python completo puede embeberse donde la l\xF3gica del juego lo necesite.\n\nMiles de t\xEDtulos comerciales y gratuitos se publican con Ren'Py, que exporta a Windows, macOS, Linux, Android, iOS y la web, e incluye soporte integrado para guardados, rollback, localizaci\xF3n y accesibilidad."
+    },
+    it: {
+      name: "Ren'Py",
+      description: "Un motore per visual novel con un linguaggio di script simile a una sceneggiatura che incorpora Python.",
+      longDescription: "Ren'Py \xE8 un motore open source per visual novel e giochi narrativi. Il suo linguaggio di script si legge come una sceneggiatura \u2014 etichette, dialoghi, menu e istruzioni di scena \u2014 mentre Python completo pu\xF2 essere incorporato ovunque serva logica di gioco.\n\nMigliaia di titoli commerciali e gratuiti sono pubblicati con Ren'Py, che esporta su Windows, macOS, Linux, Android, iOS e web, e include supporto integrato per salvataggi, rollback, localizzazione e accessibilit\xE0."
+    },
+    fr: {
+      name: "Ren'Py",
+      description: "Un moteur de visual novels au langage de script fa\xE7on sc\xE9nario, avec Python int\xE9gr\xE9.",
+      longDescription: "Ren'Py est un moteur open source pour visual novels et jeux narratifs. Son langage de script se lit comme un sc\xE9nario \u2014 \xE9tiquettes, dialogues, menus et instructions de sc\xE8ne \u2014 tandis que Python complet peut \xEAtre int\xE9gr\xE9 partout o\xF9 la logique du jeu l'exige.\n\nDes milliers de titres commerciaux et gratuits sortent sur Ren'Py, qui exporte vers Windows, macOS, Linux, Android, iOS et le web, avec une prise en charge int\xE9gr\xE9e des sauvegardes, du rollback, de la localisation et de l'accessibilit\xE9."
+    },
+    de: {
+      name: "Ren'Py",
+      description: "Eine Visual-Novel-Engine mit drehbuchartiger Skriptsprache und eingebettetem Python.",
+      longDescription: "Ren'Py ist eine Open-Source-Engine f\xFCr Visual Novels und erz\xE4hlgetriebene Spiele. Die Skriptsprache liest sich wie ein Drehbuch \u2014 Labels, Dialoge, Men\xFCs und Szenenanweisungen \u2014, w\xE4hrend vollst\xE4ndiges Python \xFCberall eingebettet werden kann, wo Spiellogik n\xF6tig ist.\n\nTausende kommerzielle und freie Titel erscheinen auf Ren'Py, das nach Windows, macOS, Linux, Android, iOS und ins Web exportiert und eingebaute Unterst\xFCtzung f\xFCr Spielst\xE4nde, Rollback, Lokalisierung und Barrierefreiheit mitbringt."
+    },
+    pt: {
+      name: "Ren'Py",
+      description: "Um motor de visual novels com linguagem de script estilo roteiro que incorpora Python.",
+      longDescription: "Ren'Py \xE9 um motor de c\xF3digo aberto para visual novels e jogos narrativos. Sua linguagem de script se l\xEA como um roteiro \u2014 r\xF3tulos, di\xE1logos, menus e instru\xE7\xF5es de cena \u2014 enquanto Python completo pode ser incorporado onde a l\xF3gica do jogo precisar.\n\nMilhares de t\xEDtulos comerciais e gratuitos s\xE3o lan\xE7ados com Ren'Py, que exporta para Windows, macOS, Linux, Android, iOS e web, e inclui suporte embutido a salvamentos, rollback, localiza\xE7\xE3o e acessibilidade."
+    }
+  }
+};
+
 // src/languages/rescript.ts
 var rescript = {
   slug: "rescript",
@@ -10596,6 +11722,9 @@ var rescript = {
   author: "ReScript Association",
   website: "https://rescript-lang.org",
   paradigms: ["functional", "statically typed", "multi-paradigm", "javascript-targeted"],
+  relations: {
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["JavaScript", "Node.js", "Browser"],
     packageManagers: ["npm", "pnpm", "Yarn"],
@@ -10641,6 +11770,7 @@ var rescript = {
 // src/languages/restructuredtext.ts
 var restructuredtext = {
   slug: "restructuredtext",
+  aliases: ["rst"],
   publishedDate: "2001-06-01",
   extensions: [".rst", ".rest"],
   author: "David Goodger / Docutils contributors",
@@ -10688,6 +11818,55 @@ var restructuredtext = {
   }
 };
 
+// src/languages/rexx.ts
+var rexx = {
+  slug: "rexx",
+  publishedDate: "1979-03-20",
+  extensions: [".rexx", ".rex"],
+  author: "Mike Cowlishaw / IBM",
+  website: "https://www.rexxla.org",
+  paradigms: ["imperative", "procedural", "scripting"],
+  tooling: {
+    runtimes: ["z/OS", "ooRexx", "Regina REXX"],
+    ecosystems: ["Mainframe", "Scripting"]
+  },
+  version: "ANSI X3.274-1996",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_rexx.svg",
+  color: "#D90E09",
+  i18n: {
+    en: {
+      name: "REXX",
+      description: "A readable IBM scripting language for mainframe automation and system glue.",
+      longDescription: "REXX (Restructured Extended Executor) is a scripting language designed by Mike Cowlishaw at IBM with an emphasis on readability and ease of learning. It became the standard automation language on IBM mainframes, driving TSO/ISPF, batch jobs, and system utilities on z/OS.\n\nBeyond the mainframe, Open Object Rexx (ooRexx) and Regina bring the language to Linux, Windows, and macOS, and REXX remains in active production use wherever decades of mainframe automation live on."
+    },
+    es: {
+      name: "REXX",
+      description: "Un lenguaje de scripting legible de IBM para automatizaci\xF3n de mainframes.",
+      longDescription: "REXX (Restructured Extended Executor) es un lenguaje de scripting dise\xF1ado por Mike Cowlishaw en IBM con \xE9nfasis en la legibilidad y la facilidad de aprendizaje. Se convirti\xF3 en el lenguaje de automatizaci\xF3n est\xE1ndar de los mainframes de IBM, controlando TSO/ISPF, trabajos batch y utilidades del sistema en z/OS.\n\nM\xE1s all\xE1 del mainframe, Open Object Rexx (ooRexx) y Regina llevan el lenguaje a Linux, Windows y macOS, y REXX sigue en uso productivo activo dondequiera que perduren d\xE9cadas de automatizaci\xF3n de mainframe."
+    },
+    it: {
+      name: "REXX",
+      description: "Un linguaggio di scripting IBM leggibile per l'automazione dei mainframe.",
+      longDescription: "REXX (Restructured Extended Executor) \xE8 un linguaggio di scripting progettato da Mike Cowlishaw in IBM con enfasi sulla leggibilit\xE0 e sulla facilit\xE0 di apprendimento. \xC8 diventato il linguaggio di automazione standard sui mainframe IBM, guidando TSO/ISPF, job batch e utility di sistema su z/OS.\n\nOltre il mainframe, Open Object Rexx (ooRexx) e Regina portano il linguaggio su Linux, Windows e macOS, e REXX rimane in uso produttivo attivo ovunque sopravvivano decenni di automazione mainframe."
+    },
+    fr: {
+      name: "REXX",
+      description: "Un langage de script IBM lisible pour l'automatisation des mainframes.",
+      longDescription: "REXX (Restructured Extended Executor) est un langage de script con\xE7u par Mike Cowlishaw chez IBM avec un accent sur la lisibilit\xE9 et la facilit\xE9 d'apprentissage. Il est devenu le langage d'automatisation standard des mainframes IBM, pilotant TSO/ISPF, les travaux batch et les utilitaires syst\xE8me sous z/OS.\n\nAu-del\xE0 du mainframe, Open Object Rexx (ooRexx) et Regina portent le langage sur Linux, Windows et macOS, et REXX reste en usage productif actif partout o\xF9 survivent des d\xE9cennies d'automatisation mainframe."
+    },
+    de: {
+      name: "REXX",
+      description: "Eine gut lesbare IBM-Skriptsprache f\xFCr Mainframe-Automatisierung.",
+      longDescription: "REXX (Restructured Extended Executor) ist eine von Mike Cowlishaw bei IBM entworfene Skriptsprache mit Schwerpunkt auf Lesbarkeit und leichter Erlernbarkeit. Sie wurde zur Standard-Automatisierungssprache auf IBM-Mainframes und steuert TSO/ISPF, Batch-Jobs und Systemwerkzeuge unter z/OS.\n\nJenseits des Mainframes bringen Open Object Rexx (ooRexx) und Regina die Sprache auf Linux, Windows und macOS, und REXX bleibt \xFCberall dort im produktiven Einsatz, wo Jahrzehnte an Mainframe-Automatisierung weiterleben."
+    },
+    pt: {
+      name: "REXX",
+      description: "Uma linguagem de script leg\xEDvel da IBM para automa\xE7\xE3o de mainframes.",
+      longDescription: "REXX (Restructured Extended Executor) \xE9 uma linguagem de script projetada por Mike Cowlishaw na IBM com \xEAnfase em legibilidade e facilidade de aprendizado. Tornou-se a linguagem de automa\xE7\xE3o padr\xE3o nos mainframes da IBM, controlando TSO/ISPF, jobs batch e utilit\xE1rios de sistema no z/OS.\n\nAl\xE9m do mainframe, o Open Object Rexx (ooRexx) e o Regina levam a linguagem para Linux, Windows e macOS, e o REXX continua em uso produtivo ativo onde quer que d\xE9cadas de automa\xE7\xE3o de mainframe sobrevivam."
+    }
+  }
+};
+
 // src/languages/roc.ts
 var roc = {
   slug: "roc",
@@ -10789,6 +11968,7 @@ var rpg = {
 // src/languages/ruby.ts
 var ruby = {
   slug: "ruby",
+  aliases: ["rb"],
   publishedDate: "1995-12-21",
   extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"],
   author: "Yukihiro Matsumoto",
@@ -11042,6 +12222,10 @@ var scss = {
   author: "Hampton Catlin / Natalie Weizenbaum / Chris Eppstein",
   website: "https://sass-lang.com",
   paradigms: ["declarative", "stylesheet", "preprocessor"],
+  relations: {
+    supersetOf: ["css"],
+    compilesTo: ["css"]
+  },
   tooling: {
     runtimes: ["Dart Sass"],
     packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
@@ -11136,6 +12320,7 @@ var self = {
 // src/languages/simula.ts
 var simula = {
   slug: "simula",
+  status: "historical",
   publishedDate: "1962-01-01",
   extensions: [".sim", ".simula"],
   author: "Ole-Johan Dahl and Kristen Nygaard",
@@ -11146,7 +12331,7 @@ var simula = {
     ecosystems: ["Simulation", "Language history"]
   },
   version: "Simula 67",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Si",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/simula.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -11182,6 +12367,58 @@ var simula = {
   }
 };
 
+// src/languages/slang.ts
+var slang = {
+  slug: "slang",
+  publishedDate: "2017-01-01",
+  extensions: [".slang"],
+  author: "NVIDIA / Khronos Group",
+  website: "https://shader-slang.org",
+  paradigms: ["imperative", "shader", "generic"],
+  relations: {
+    compilesTo: ["hlsl", "glsl", "metal", "wgsl"]
+  },
+  tooling: {
+    runtimes: ["Vulkan", "Direct3D", "Metal", "WebGPU"],
+    ecosystems: ["GPU", "Graphics", "Game Development"]
+  },
+  version: "stable",
+  logo: "https://avatars.githubusercontent.com/u/29205606?v=4",
+  color: "#1FBEC9",
+  i18n: {
+    en: {
+      name: "Slang",
+      description: "A modern shading language that cross-compiles to HLSL, GLSL, Metal, and WGSL.",
+      longDescription: "Slang is a shading language that extends HLSL with modules, generics, interfaces, and automatic differentiation. A single Slang codebase cross-compiles to HLSL, GLSL, SPIR-V, Metal, WGSL, and CUDA, eliminating per-API shader duplication.\n\nOriginally developed at NVIDIA and now hosted by the Khronos Group, Slang powers production renderers and research frameworks, with differentiable shading making it popular for machine-learning graphics."
+    },
+    es: {
+      name: "Slang",
+      description: "Un lenguaje de shaders moderno que compila de forma cruzada a HLSL, GLSL, Metal y WGSL.",
+      longDescription: "Slang es un lenguaje de shaders que extiende HLSL con m\xF3dulos, gen\xE9ricos, interfaces y diferenciaci\xF3n autom\xE1tica. Una sola base de c\xF3digo Slang se compila de forma cruzada a HLSL, GLSL, SPIR-V, Metal, WGSL y CUDA, eliminando la duplicaci\xF3n de shaders por API.\n\nDesarrollado originalmente en NVIDIA y ahora alojado por el Grupo Khronos, Slang impulsa renderizadores de producci\xF3n y frameworks de investigaci\xF3n, y su shading diferenciable lo hace popular en gr\xE1ficos con machine learning."
+    },
+    it: {
+      name: "Slang",
+      description: "Un moderno linguaggio di shading che compila verso HLSL, GLSL, Metal e WGSL.",
+      longDescription: "Slang \xE8 un linguaggio di shading che estende HLSL con moduli, generics, interfacce e differenziazione automatica. Una singola base di codice Slang si compila verso HLSL, GLSL, SPIR-V, Metal, WGSL e CUDA, eliminando la duplicazione degli shader per ogni API.\n\nSviluppato originariamente da NVIDIA e ora ospitato dal Khronos Group, Slang alimenta renderer di produzione e framework di ricerca, e lo shading differenziabile lo rende popolare nella grafica per il machine learning."
+    },
+    fr: {
+      name: "Slang",
+      description: "Un langage de shading moderne qui se compile vers HLSL, GLSL, Metal et WGSL.",
+      longDescription: "Slang est un langage de shading qui \xE9tend HLSL avec des modules, des g\xE9n\xE9riques, des interfaces et la diff\xE9rentiation automatique. Une seule base de code Slang se compile vers HLSL, GLSL, SPIR-V, Metal, WGSL et CUDA, \xE9liminant la duplication de shaders par API.\n\nD\xE9velopp\xE9 \xE0 l'origine chez NVIDIA et d\xE9sormais h\xE9berg\xE9 par le Khronos Group, Slang alimente des moteurs de rendu en production et des frameworks de recherche, et son shading diff\xE9rentiable le rend populaire pour les graphismes en machine learning."
+    },
+    de: {
+      name: "Slang",
+      description: "Eine moderne Shading-Sprache, die nach HLSL, GLSL, Metal und WGSL cross-kompiliert.",
+      longDescription: "Slang ist eine Shading-Sprache, die HLSL um Module, Generics, Interfaces und automatische Differentiation erweitert. Eine einzige Slang-Codebasis wird nach HLSL, GLSL, SPIR-V, Metal, WGSL und CUDA cross-kompiliert und beseitigt so die Shader-Duplikation pro API.\n\nUrspr\xFCnglich bei NVIDIA entwickelt und heute von der Khronos Group betreut, treibt Slang Produktions-Renderer und Forschungs-Frameworks an; differenzierbares Shading macht es in der Machine-Learning-Grafik beliebt."
+    },
+    pt: {
+      name: "Slang",
+      description: "Uma linguagem de shaders moderna que compila para HLSL, GLSL, Metal e WGSL.",
+      longDescription: "Slang \xE9 uma linguagem de shaders que estende o HLSL com m\xF3dulos, gen\xE9ricos, interfaces e diferencia\xE7\xE3o autom\xE1tica. Uma \xFAnica base de c\xF3digo Slang \xE9 compilada para HLSL, GLSL, SPIR-V, Metal, WGSL e CUDA, eliminando a duplica\xE7\xE3o de shaders por API.\n\nDesenvolvida originalmente na NVIDIA e agora mantida pelo Khronos Group, a Slang move renderizadores de produ\xE7\xE3o e frameworks de pesquisa, e o shading diferenci\xE1vel a torna popular em gr\xE1ficos com machine learning."
+    }
+  }
+};
+
 // src/languages/smalltalk.ts
 var smalltalk = {
   slug: "smalltalk",
@@ -11281,6 +12518,56 @@ var smarty = {
   }
 };
 
+// src/languages/smithy.ts
+var smithy = {
+  slug: "smithy",
+  publishedDate: "2019-01-01",
+  extensions: [".smithy"],
+  author: "Amazon Web Services",
+  website: "https://smithy.io",
+  paradigms: ["declarative", "interface-definition"],
+  tooling: {
+    runtimes: ["JVM"],
+    packageManagers: ["Gradle", "Maven"],
+    ecosystems: ["Cloud", "API Design"]
+  },
+  version: "IDL 2.0",
+  logo: "https://avatars.githubusercontent.com/u/133827778?v=4",
+  color: "#FF9900",
+  i18n: {
+    en: {
+      name: "Smithy",
+      description: "AWS's protocol-agnostic interface definition language for modeling services.",
+      longDescription: "Smithy is an interface definition language created by AWS to model services, resources, and operations independently of any protocol or transport. Models are decorated with traits \u2014 validation, authentication, pagination, error behavior \u2014 from which code generators produce clients, servers, and documentation.\n\nAWS uses Smithy to define its own service APIs and generate its SDKs. The open-source toolchain includes a Java-based build system, model validation, and generators for multiple target languages."
+    },
+    es: {
+      name: "Smithy",
+      description: "El lenguaje de definici\xF3n de interfaces de AWS, agn\xF3stico de protocolo, para modelar servicios.",
+      longDescription: "Smithy es un lenguaje de definici\xF3n de interfaces creado por AWS para modelar servicios, recursos y operaciones con independencia de cualquier protocolo o transporte. Los modelos se decoran con traits \u2014 validaci\xF3n, autenticaci\xF3n, paginaci\xF3n, comportamiento de errores \u2014 a partir de los cuales los generadores producen clientes, servidores y documentaci\xF3n.\n\nAWS usa Smithy para definir sus propias APIs de servicio y generar sus SDKs. La cadena de herramientas de c\xF3digo abierto incluye un sistema de build basado en Java, validaci\xF3n de modelos y generadores para m\xFAltiples lenguajes destino."
+    },
+    it: {
+      name: "Smithy",
+      description: "Il linguaggio di definizione delle interfacce di AWS, agnostico rispetto al protocollo.",
+      longDescription: "Smithy \xE8 un linguaggio di definizione delle interfacce creato da AWS per modellare servizi, risorse e operazioni indipendentemente da qualsiasi protocollo o trasporto. I modelli sono decorati con trait \u2014 validazione, autenticazione, paginazione, comportamento degli errori \u2014 dai quali i generatori producono client, server e documentazione.\n\nAWS usa Smithy per definire le proprie API di servizio e generare i propri SDK. La toolchain open source include un sistema di build basato su Java, la validazione dei modelli e generatori per pi\xF9 linguaggi di destinazione."
+    },
+    fr: {
+      name: "Smithy",
+      description: "Le langage de d\xE9finition d'interfaces d'AWS, ind\xE9pendant du protocole, pour mod\xE9liser des services.",
+      longDescription: "Smithy est un langage de d\xE9finition d'interfaces cr\xE9\xE9 par AWS pour mod\xE9liser services, ressources et op\xE9rations ind\xE9pendamment de tout protocole ou transport. Les mod\xE8les sont d\xE9cor\xE9s de traits \u2014 validation, authentification, pagination, comportement d'erreur \u2014 \xE0 partir desquels des g\xE9n\xE9rateurs produisent clients, serveurs et documentation.\n\nAWS utilise Smithy pour d\xE9finir ses propres API de service et g\xE9n\xE9rer ses SDK. La cha\xEEne d'outils open source comprend un syst\xE8me de build en Java, la validation de mod\xE8les et des g\xE9n\xE9rateurs pour plusieurs langages cibles."
+    },
+    de: {
+      name: "Smithy",
+      description: "AWS' protokollunabh\xE4ngige Schnittstellenbeschreibungssprache zur Modellierung von Services.",
+      longDescription: "Smithy ist eine von AWS geschaffene Schnittstellenbeschreibungssprache, um Services, Ressourcen und Operationen unabh\xE4ngig von Protokoll oder Transport zu modellieren. Modelle werden mit Traits versehen \u2014 Validierung, Authentifizierung, Paginierung, Fehlerverhalten \u2014, aus denen Codegeneratoren Clients, Server und Dokumentation erzeugen.\n\nAWS definiert mit Smithy seine eigenen Service-APIs und generiert daraus seine SDKs. Die Open-Source-Toolchain umfasst ein Java-basiertes Build-System, Modellvalidierung und Generatoren f\xFCr mehrere Zielsprachen."
+    },
+    pt: {
+      name: "Smithy",
+      description: "A linguagem de defini\xE7\xE3o de interfaces da AWS, agn\xF3stica de protocolo, para modelar servi\xE7os.",
+      longDescription: "Smithy \xE9 uma linguagem de defini\xE7\xE3o de interfaces criada pela AWS para modelar servi\xE7os, recursos e opera\xE7\xF5es independentemente de qualquer protocolo ou transporte. Os modelos s\xE3o decorados com traits \u2014 valida\xE7\xE3o, autentica\xE7\xE3o, pagina\xE7\xE3o, comportamento de erros \u2014 a partir dos quais geradores produzem clientes, servidores e documenta\xE7\xE3o.\n\nA AWS usa Smithy para definir suas pr\xF3prias APIs de servi\xE7o e gerar seus SDKs. A toolchain de c\xF3digo aberto inclui um sistema de build baseado em Java, valida\xE7\xE3o de modelos e geradores para v\xE1rias linguagens de destino."
+    }
+  }
+};
+
 // src/languages/snakemake.ts
 var snakemake = {
   slug: "snakemake",
@@ -11333,6 +12620,7 @@ var snakemake = {
 // src/languages/snobol.ts
 var snobol = {
   slug: "snobol",
+  status: "historical",
   publishedDate: "1962-01-01",
   extensions: [".sno", ".snobol"],
   author: "David J. Farber, Ralph Griswold, and Ivan P. Polonsky",
@@ -11343,7 +12631,7 @@ var snobol = {
     ecosystems: ["Text processing", "Language history"]
   },
   version: "SNOBOL4",
-  logo: "https://dummyimage.com/32x32/7C2D12/ffffff.png&text=SN",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/snobol.svg",
   color: "#7C2D12",
   i18n: {
     en: {
@@ -11491,7 +12779,7 @@ var spark = {
     ecosystems: ["Ada", "Embedded", "Safety-critical software"]
   },
   version: "SPARK Community 2021",
-  logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=SP",
+  logo: "https://avatars.githubusercontent.com/u/7767877?v=4",
   color: "#DC2626",
   i18n: {
     en: {
@@ -11638,7 +12926,7 @@ var spss = {
     ecosystems: ["Statistics", "Data Analysis", "Social Sciences", "Business Intelligence"]
   },
   version: "29.0",
-  logo: "https://dummyimage.com/32x32/052FAD/ffffff.png&text=SPSS",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/e/ea/SPSS_logo.svg",
   color: "#052FAD",
   i18n: {
     en: {
@@ -11732,7 +13020,7 @@ var squirrel = {
     ecosystems: ["Game Development", "Embedded Scripting", "Valve Source Engine"]
   },
   version: "3.2",
-  logo: "https://dummyimage.com/32x32/CC4A00/ffffff.png&text=SQ",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_squirrel.svg",
   color: "#CC4A00",
   i18n: {
     en: {
@@ -11924,6 +13212,10 @@ var stylus = {
   author: "TJ Holowaychuk / Stylus contributors",
   website: "https://stylus-lang.com",
   paradigms: ["stylesheet", "declarative", "preprocessor"],
+  relations: {
+    dialectOf: ["css"],
+    compilesTo: ["css"]
+  },
   tooling: {
     runtimes: ["Node.js"],
     packageManagers: ["npm", "pnpm", "Yarn"],
@@ -11966,6 +13258,57 @@ var stylus = {
   }
 };
 
+// src/languages/supercollider.ts
+var supercollider = {
+  slug: "supercollider",
+  aliases: ["sclang"],
+  publishedDate: "1996-03-01",
+  extensions: [".scd", ".sc"],
+  author: "James McCartney",
+  website: "https://supercollider.github.io",
+  paradigms: ["object-oriented", "functional", "audio"],
+  tooling: {
+    runtimes: ["sclang", "scsynth"],
+    packageManagers: ["Quarks"],
+    ecosystems: ["Audio", "Music", "Creative Coding"]
+  },
+  version: "3.13.0",
+  logo: "https://avatars.githubusercontent.com/u/1706741?v=4",
+  color: "#46390B",
+  i18n: {
+    en: {
+      name: "SuperCollider",
+      description: "A platform and language for real-time audio synthesis and algorithmic composition.",
+      longDescription: "SuperCollider pairs an interpreted, Smalltalk-inspired language (sclang) with a real-time audio synthesis server (scsynth). Code builds synth definitions, schedules musical patterns, and rewires signal graphs live, making it a foundation of the live-coding and computer-music communities.\n\nOpen source since 2002, SuperCollider runs on Linux, macOS, and Windows, extends through Quarks packages, and serves as the synthesis engine behind environments such as TidalCycles."
+    },
+    es: {
+      name: "SuperCollider",
+      description: "Una plataforma y lenguaje para s\xEDntesis de audio en tiempo real y composici\xF3n algor\xEDtmica.",
+      longDescription: "SuperCollider combina un lenguaje interpretado inspirado en Smalltalk (sclang) con un servidor de s\xEDntesis de audio en tiempo real (scsynth). El c\xF3digo construye definiciones de sintetizadores, agenda patrones musicales y recablea grafos de se\xF1al en vivo, siendo una base de las comunidades de live coding y m\xFAsica por computadora.\n\nDe c\xF3digo abierto desde 2002, SuperCollider corre en Linux, macOS y Windows, se extiende mediante paquetes Quarks y act\xFAa como motor de s\xEDntesis detr\xE1s de entornos como TidalCycles."
+    },
+    it: {
+      name: "SuperCollider",
+      description: "Una piattaforma e linguaggio per la sintesi audio in tempo reale e la composizione algoritmica.",
+      longDescription: "SuperCollider abbina un linguaggio interpretato ispirato a Smalltalk (sclang) a un server di sintesi audio in tempo reale (scsynth). Il codice costruisce definizioni di sintetizzatori, pianifica pattern musicali e ricollega grafi di segnale dal vivo, costituendo una base delle comunit\xE0 di live coding e computer music.\n\nOpen source dal 2002, SuperCollider gira su Linux, macOS e Windows, si estende tramite i pacchetti Quarks e funge da motore di sintesi dietro ambienti come TidalCycles."
+    },
+    fr: {
+      name: "SuperCollider",
+      description: "Une plateforme et un langage pour la synth\xE8se audio temps r\xE9el et la composition algorithmique.",
+      longDescription: "SuperCollider associe un langage interpr\xE9t\xE9 inspir\xE9 de Smalltalk (sclang) \xE0 un serveur de synth\xE8se audio temps r\xE9el (scsynth). Le code construit des d\xE9finitions de synth\xE9s, planifie des motifs musicaux et rec\xE2ble des graphes de signal en direct, ce qui en fait un pilier des communaut\xE9s de live coding et de musique par ordinateur.\n\nOpen source depuis 2002, SuperCollider fonctionne sous Linux, macOS et Windows, s'\xE9tend via les paquets Quarks et sert de moteur de synth\xE8se \xE0 des environnements comme TidalCycles."
+    },
+    de: {
+      name: "SuperCollider",
+      description: "Eine Plattform und Sprache f\xFCr Echtzeit-Audiosynthese und algorithmische Komposition.",
+      longDescription: "SuperCollider verbindet eine interpretierte, Smalltalk-inspirierte Sprache (sclang) mit einem Echtzeit-Audiosynthese-Server (scsynth). Code baut Synth-Definitionen, plant musikalische Patterns und verdrahtet Signalgraphen live um \u2014 ein Fundament der Live-Coding- und Computermusik-Szene.\n\nSeit 2002 Open Source, l\xE4uft SuperCollider auf Linux, macOS und Windows, wird \xFCber Quarks-Pakete erweitert und dient als Synthese-Engine hinter Umgebungen wie TidalCycles."
+    },
+    pt: {
+      name: "SuperCollider",
+      description: "Uma plataforma e linguagem para s\xEDntese de \xE1udio em tempo real e composi\xE7\xE3o algor\xEDtmica.",
+      longDescription: "O SuperCollider combina uma linguagem interpretada inspirada em Smalltalk (sclang) com um servidor de s\xEDntese de \xE1udio em tempo real (scsynth). O c\xF3digo constr\xF3i defini\xE7\xF5es de sintetizadores, agenda padr\xF5es musicais e religa grafos de sinal ao vivo, sendo uma base das comunidades de live coding e m\xFAsica computacional.\n\nDe c\xF3digo aberto desde 2002, o SuperCollider roda em Linux, macOS e Windows, estende-se por meio de pacotes Quarks e serve como motor de s\xEDntese por tr\xE1s de ambientes como o TidalCycles."
+    }
+  }
+};
+
 // src/languages/svelte.ts
 var svelte = {
   slug: "svelte",
@@ -11974,6 +13317,9 @@ var svelte = {
   author: "Rich Harris / Svelte contributors",
   website: "https://svelte.dev",
   paradigms: ["component-based", "declarative", "reactive", "compiled"],
+  relations: {
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["Browser", "Node.js"],
     packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
@@ -12114,6 +13460,57 @@ var svn = {
   }
 };
 
+// src/languages/sway.ts
+var sway = {
+  slug: "sway",
+  status: "experimental",
+  publishedDate: "2021-01-01",
+  extensions: [".sw"],
+  author: "Fuel Labs",
+  website: "https://fuellabs.github.io/sway",
+  paradigms: ["imperative", "functional", "smart-contract"],
+  tooling: {
+    runtimes: ["FuelVM"],
+    packageManagers: ["Forc"],
+    ecosystems: ["Blockchain", "Web3"]
+  },
+  version: "0.69.0",
+  logo: "https://avatars.githubusercontent.com/u/55993183?v=4",
+  color: "#00F58C",
+  i18n: {
+    en: {
+      name: "Sway",
+      description: "A Rust-inspired smart contract language for the Fuel blockchain virtual machine.",
+      longDescription: "Sway is a domain-specific language for writing smart contracts on the FuelVM, the execution layer built by Fuel Labs. It borrows Rust syntax, traits, and safety principles while adding blockchain-native concepts such as contract storage, predicates, and scripts.\n\nThe Forc toolchain manages builds, dependencies, testing, and deployment, giving Sway developers a cargo-like workflow for the Fuel modular rollup ecosystem."
+    },
+    es: {
+      name: "Sway",
+      description: "Un lenguaje de contratos inteligentes inspirado en Rust para la m\xE1quina virtual de Fuel.",
+      longDescription: "Sway es un lenguaje de dominio espec\xEDfico para escribir contratos inteligentes en la FuelVM, la capa de ejecuci\xF3n construida por Fuel Labs. Toma prestados la sintaxis, los traits y los principios de seguridad de Rust, a\xF1adiendo conceptos nativos de blockchain como almacenamiento de contratos, predicados y scripts.\n\nLa cadena de herramientas Forc gestiona builds, dependencias, pruebas y despliegue, dando a los desarrolladores de Sway un flujo estilo cargo para el ecosistema de rollups modulares de Fuel."
+    },
+    it: {
+      name: "Sway",
+      description: "Un linguaggio per smart contract ispirato a Rust per la macchina virtuale di Fuel.",
+      longDescription: "Sway \xE8 un linguaggio di dominio specifico per scrivere smart contract sulla FuelVM, il livello di esecuzione costruito da Fuel Labs. Prende in prestito la sintassi, i trait e i principi di sicurezza di Rust, aggiungendo concetti nativi della blockchain come lo storage dei contratti, i predicati e gli script.\n\nLa toolchain Forc gestisce build, dipendenze, test e deployment, offrendo agli sviluppatori Sway un flusso di lavoro in stile cargo per l'ecosistema di rollup modulari di Fuel."
+    },
+    fr: {
+      name: "Sway",
+      description: "Un langage de smart contracts inspir\xE9 de Rust pour la machine virtuelle Fuel.",
+      longDescription: "Sway est un langage d\xE9di\xE9 \xE0 l'\xE9criture de smart contracts sur la FuelVM, la couche d'ex\xE9cution construite par Fuel Labs. Il emprunte la syntaxe, les traits et les principes de s\xFBret\xE9 de Rust, en ajoutant des concepts propres \xE0 la blockchain comme le stockage de contrats, les pr\xE9dicats et les scripts.\n\nLa cha\xEEne d'outils Forc g\xE8re la compilation, les d\xE9pendances, les tests et le d\xE9ploiement, offrant aux d\xE9veloppeurs Sway un flux de travail \xE0 la cargo pour l'\xE9cosyst\xE8me de rollups modulaires de Fuel."
+    },
+    de: {
+      name: "Sway",
+      description: "Eine Rust-inspirierte Smart-Contract-Sprache f\xFCr die virtuelle Maschine von Fuel.",
+      longDescription: "Sway ist eine dom\xE4nenspezifische Sprache zum Schreiben von Smart Contracts auf der FuelVM, der von Fuel Labs entwickelten Ausf\xFChrungsschicht. Sie \xFCbernimmt Syntax, Traits und Sicherheitsprinzipien von Rust und erg\xE4nzt Blockchain-native Konzepte wie Contract-Storage, Pr\xE4dikate und Skripte.\n\nDie Forc-Toolchain verwaltet Builds, Abh\xE4ngigkeiten, Tests und Deployment und bietet Sway-Entwicklern einen cargo-\xE4hnlichen Workflow f\xFCr das modulare Rollup-\xD6kosystem von Fuel."
+    },
+    pt: {
+      name: "Sway",
+      description: "Uma linguagem de contratos inteligentes inspirada em Rust para a m\xE1quina virtual da Fuel.",
+      longDescription: "Sway \xE9 uma linguagem de dom\xEDnio espec\xEDfico para escrever contratos inteligentes na FuelVM, a camada de execu\xE7\xE3o constru\xEDda pela Fuel Labs. Ela toma emprestados a sintaxe, os traits e os princ\xEDpios de seguran\xE7a do Rust, adicionando conceitos nativos de blockchain como armazenamento de contratos, predicados e scripts.\n\nA toolchain Forc gerencia builds, depend\xEAncias, testes e implanta\xE7\xE3o, dando aos desenvolvedores Sway um fluxo de trabalho no estilo cargo para o ecossistema de rollups modulares da Fuel."
+    }
+  }
+};
+
 // src/languages/swift.ts
 var swift = {
   slug: "swift",
@@ -12227,7 +13624,7 @@ var tcsh = {
     ecosystems: ["Unix", "BSD"]
   },
   version: "6.24.16",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=TC",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/tcsh.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -12266,6 +13663,7 @@ var tcsh = {
 // src/languages/tex.ts
 var tex = {
   slug: "tex",
+  aliases: ["latex"],
   publishedDate: "1978-01-01",
   extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"],
   author: "Donald Knuth",
@@ -12562,6 +13960,9 @@ var tsql = {
   author: "Sybase / Microsoft",
   website: "https://learn.microsoft.com/en-us/sql/t-sql/language-reference",
   paradigms: ["procedural", "declarative", "database", "imperative"],
+  relations: {
+    dialectOf: ["sql"]
+  },
   tooling: {
     runtimes: [
       "SQL Server",
@@ -12710,11 +14111,16 @@ var twig = {
 // src/languages/typescript.ts
 var typescript = {
   slug: "typescript",
+  aliases: ["ts"],
   publishedDate: "2012-10-01",
   extensions: [".ts", ".tsx", ".mts", ".cts"],
   author: "Anders Hejlsberg / Microsoft",
   website: "https://www.typescriptlang.org",
   paradigms: ["object-oriented", "functional", "imperative", "generic"],
+  relations: {
+    supersetOf: ["javascript"],
+    compilesTo: ["javascript"]
+  },
   tooling: {
     runtimes: ["Browser", "Node.js", "Deno", "Bun"],
     packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
@@ -12757,6 +14163,60 @@ var typescript = {
   }
 };
 
+// src/languages/typespec.ts
+var typespec = {
+  slug: "typespec",
+  aliases: ["cadl"],
+  publishedDate: "2022-09-07",
+  extensions: [".tsp"],
+  author: "Microsoft",
+  website: "https://typespec.io",
+  paradigms: ["declarative", "interface-definition"],
+  relations: {
+    compilesTo: ["openapi", "protobuf", "json"]
+  },
+  tooling: {
+    runtimes: ["Node.js"],
+    packageManagers: ["npm"],
+    ecosystems: ["Cloud", "API Design"]
+  },
+  version: "1.0",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/typespec.svg",
+  color: "#4B3CC4",
+  i18n: {
+    en: {
+      name: "TypeSpec",
+      description: "A TypeScript-inspired language from Microsoft for describing APIs, emitting OpenAPI and more.",
+      longDescription: "TypeSpec (formerly Cadl) is an API description language from Microsoft with TypeScript-inspired syntax. Reusable models, decorators, and interfaces describe REST, gRPC, and event-driven APIs at a higher level than hand-written specifications.\n\nEmitters compile TypeSpec into OpenAPI documents, Protobuf definitions, JSON Schema, and client code. Microsoft uses it to define Azure service APIs, keeping large API surfaces consistent from one concise source of truth."
+    },
+    es: {
+      name: "TypeSpec",
+      description: "Un lenguaje de Microsoft inspirado en TypeScript para describir APIs, emitiendo OpenAPI y m\xE1s.",
+      longDescription: "TypeSpec (antes Cadl) es un lenguaje de descripci\xF3n de APIs de Microsoft con sintaxis inspirada en TypeScript. Modelos reutilizables, decoradores e interfaces describen APIs REST, gRPC y orientadas a eventos a un nivel m\xE1s alto que las especificaciones escritas a mano.\n\nLos emisores compilan TypeSpec a documentos OpenAPI, definiciones Protobuf, JSON Schema y c\xF3digo cliente. Microsoft lo usa para definir las APIs de servicios de Azure, manteniendo superficies de API enormes consistentes desde una sola fuente de verdad concisa."
+    },
+    it: {
+      name: "TypeSpec",
+      description: "Un linguaggio Microsoft ispirato a TypeScript per descrivere API, generando OpenAPI e altro.",
+      longDescription: "TypeSpec (ex Cadl) \xE8 un linguaggio di descrizione delle API di Microsoft con sintassi ispirata a TypeScript. Modelli riutilizzabili, decoratori e interfacce descrivono API REST, gRPC e a eventi a un livello pi\xF9 alto delle specifiche scritte a mano.\n\nGli emitter compilano TypeSpec in documenti OpenAPI, definizioni Protobuf, JSON Schema e codice client. Microsoft lo usa per definire le API dei servizi Azure, mantenendo superfici API estese coerenti da un'unica fonte di verit\xE0 concisa."
+    },
+    fr: {
+      name: "TypeSpec",
+      description: "Un langage Microsoft inspir\xE9 de TypeScript pour d\xE9crire des API, g\xE9n\xE9rant OpenAPI et plus.",
+      longDescription: "TypeSpec (anciennement Cadl) est un langage de description d'API de Microsoft \xE0 la syntaxe inspir\xE9e de TypeScript. Des mod\xE8les r\xE9utilisables, des d\xE9corateurs et des interfaces d\xE9crivent des API REST, gRPC et \xE9v\xE9nementielles \xE0 un niveau plus \xE9lev\xE9 que les sp\xE9cifications \xE9crites \xE0 la main.\n\nDes \xE9metteurs compilent TypeSpec en documents OpenAPI, d\xE9finitions Protobuf, JSON Schema et code client. Microsoft l'utilise pour d\xE9finir les API des services Azure, en gardant de vastes surfaces d'API coh\xE9rentes depuis une source de v\xE9rit\xE9 unique et concise."
+    },
+    de: {
+      name: "TypeSpec",
+      description: "Eine TypeScript-inspirierte Sprache von Microsoft zur API-Beschreibung, die OpenAPI und mehr erzeugt.",
+      longDescription: "TypeSpec (fr\xFCher Cadl) ist eine API-Beschreibungssprache von Microsoft mit TypeScript-inspirierter Syntax. Wiederverwendbare Modelle, Dekoratoren und Interfaces beschreiben REST-, gRPC- und ereignisgetriebene APIs auf h\xF6herem Niveau als handgeschriebene Spezifikationen.\n\nEmitter kompilieren TypeSpec zu OpenAPI-Dokumenten, Protobuf-Definitionen, JSON Schema und Client-Code. Microsoft definiert damit die Azure-Service-APIs und h\xE4lt gro\xDFe API-Oberfl\xE4chen von einer knappen Single Source of Truth aus konsistent."
+    },
+    pt: {
+      name: "TypeSpec",
+      description: "Uma linguagem da Microsoft inspirada em TypeScript para descrever APIs, emitindo OpenAPI e mais.",
+      longDescription: "TypeSpec (antes Cadl) \xE9 uma linguagem de descri\xE7\xE3o de APIs da Microsoft com sintaxe inspirada em TypeScript. Modelos reutiliz\xE1veis, decoradores e interfaces descrevem APIs REST, gRPC e orientadas a eventos em um n\xEDvel mais alto do que especifica\xE7\xF5es escritas \xE0 m\xE3o.\n\nOs emissores compilam TypeSpec em documentos OpenAPI, defini\xE7\xF5es Protobuf, JSON Schema e c\xF3digo cliente. A Microsoft a usa para definir as APIs dos servi\xE7os do Azure, mantendo grandes superf\xEDcies de API consistentes a partir de uma \xFAnica fonte de verdade concisa."
+    }
+  }
+};
+
 // src/languages/typst.ts
 var typst = {
   slug: "typst",
@@ -12865,6 +14325,9 @@ var v = {
   author: "Alexander Medvednikov / V contributors",
   website: "https://vlang.io",
   paradigms: ["imperative", "systems", "multi-paradigm", "statically typed"],
+  relations: {
+    compilesTo: ["c"]
+  },
   tooling: {
     runtimes: ["V compiler"],
     packageManagers: ["vpm"],
@@ -12960,6 +14423,7 @@ var vala = {
 // src/languages/vale.ts
 var vale = {
   slug: "vale",
+  status: "experimental",
   publishedDate: "2018-01-01",
   extensions: [".vale"],
   author: "Evan Ovadia",
@@ -12970,7 +14434,7 @@ var vale = {
     ecosystems: ["Native applications", "Systems programming"]
   },
   version: "experimental",
-  logo: "https://dummyimage.com/32x32/059669/ffffff.png&text=Va",
+  logo: "https://avatars.githubusercontent.com/u/67560249?v=4",
   color: "#059669",
   i18n: {
     en: {
@@ -13014,11 +14478,14 @@ var vba = {
   author: "Microsoft",
   website: "https://learn.microsoft.com/en-us/office/vba/api/overview/",
   paradigms: ["imperative", "object-oriented", "event-driven"],
+  relations: {
+    dialectOf: ["visual-basic"]
+  },
   tooling: {
     ecosystems: ["Microsoft Office", "Excel", "Access", "Word", "Outlook"]
   },
   version: "VBA 7.1",
-  logo: "https://dummyimage.com/32x32/217346/ffffff.png&text=VBA",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_vba.svg",
   color: "#217346",
   i18n: {
     en: {
@@ -13054,6 +14521,59 @@ var vba = {
   }
 };
 
+// src/languages/vbscript.ts
+var vbscript = {
+  slug: "vbscript",
+  status: "legacy",
+  publishedDate: "1996-08-01",
+  extensions: [".vbs", ".vbe"],
+  author: "Microsoft",
+  website: "https://learn.microsoft.com/en-us/previous-versions/t0aew7h6(v=vs.85)",
+  paradigms: ["imperative", "object-based", "scripting"],
+  relations: {
+    dialectOf: ["visual-basic"]
+  },
+  tooling: {
+    runtimes: ["Windows Script Host", "Classic ASP", "Internet Explorer"],
+    ecosystems: ["Windows", "Scripting"]
+  },
+  version: "5.8",
+  logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/vbscript.svg",
+  color: "#15DCDC",
+  i18n: {
+    en: {
+      name: "VBScript",
+      description: "A lightweight Visual Basic dialect for Windows automation and Classic ASP.",
+      longDescription: "VBScript is a scripting language modeled on Visual Basic and executed by the Windows Script Host, Classic ASP, and legacy Internet Explorer. It was widely used for Windows administration, logon scripts, and early server-side web pages.\n\nMicrosoft has deprecated VBScript and is phasing it out of Windows in favor of PowerShell and JavaScript, but large volumes of .vbs automation still run in enterprise environments."
+    },
+    es: {
+      name: "VBScript",
+      description: "Un dialecto ligero de Visual Basic para automatizaci\xF3n de Windows y ASP cl\xE1sico.",
+      longDescription: "VBScript es un lenguaje de scripting inspirado en Visual Basic y ejecutado por Windows Script Host, ASP cl\xE1sico e Internet Explorer heredado. Se us\xF3 ampliamente para administraci\xF3n de Windows, scripts de inicio de sesi\xF3n y las primeras p\xE1ginas web del lado del servidor.\n\nMicrosoft ha marcado VBScript como obsoleto y lo est\xE1 retirando de Windows en favor de PowerShell y JavaScript, pero grandes vol\xFAmenes de automatizaci\xF3n .vbs siguen ejecut\xE1ndose en entornos empresariales."
+    },
+    it: {
+      name: "VBScript",
+      description: "Un dialetto leggero di Visual Basic per automazione Windows e ASP classico.",
+      longDescription: "VBScript \xE8 un linguaggio di scripting modellato su Visual Basic ed eseguito da Windows Script Host, ASP classico e dal vecchio Internet Explorer. \xC8 stato ampiamente usato per l'amministrazione di Windows, gli script di accesso e le prime pagine web lato server.\n\nMicrosoft ha deprecato VBScript e lo sta rimuovendo da Windows in favore di PowerShell e JavaScript, ma grandi volumi di automazione .vbs sono ancora in esecuzione negli ambienti aziendali."
+    },
+    fr: {
+      name: "VBScript",
+      description: "Un dialecte l\xE9ger de Visual Basic pour l'automatisation Windows et l'ASP classique.",
+      longDescription: "VBScript est un langage de script inspir\xE9 de Visual Basic et ex\xE9cut\xE9 par Windows Script Host, l'ASP classique et l'ancien Internet Explorer. Il a \xE9t\xE9 largement utilis\xE9 pour l'administration Windows, les scripts d'ouverture de session et les premi\xE8res pages web c\xF4t\xE9 serveur.\n\nMicrosoft a d\xE9pr\xE9ci\xE9 VBScript et le retire progressivement de Windows au profit de PowerShell et de JavaScript, mais de grands volumes d'automatisation .vbs tournent encore dans les environnements d'entreprise."
+    },
+    de: {
+      name: "VBScript",
+      description: "Ein leichter Visual-Basic-Dialekt f\xFCr Windows-Automatisierung und Classic ASP.",
+      longDescription: "VBScript ist eine an Visual Basic angelehnte Skriptsprache, die vom Windows Script Host, Classic ASP und dem alten Internet Explorer ausgef\xFChrt wird. Sie wurde breit f\xFCr Windows-Administration, Anmeldeskripte und fr\xFChe serverseitige Webseiten eingesetzt.\n\nMicrosoft hat VBScript als veraltet markiert und entfernt es schrittweise aus Windows zugunsten von PowerShell und JavaScript, aber gro\xDFe Mengen an .vbs-Automatisierung laufen weiterhin in Unternehmensumgebungen."
+    },
+    pt: {
+      name: "VBScript",
+      description: "Um dialeto leve de Visual Basic para automa\xE7\xE3o do Windows e ASP cl\xE1ssico.",
+      longDescription: "VBScript \xE9 uma linguagem de script baseada no Visual Basic e executada pelo Windows Script Host, pelo ASP cl\xE1ssico e pelo antigo Internet Explorer. Foi amplamente usada para administra\xE7\xE3o do Windows, scripts de logon e as primeiras p\xE1ginas web do lado do servidor.\n\nA Microsoft descontinuou o VBScript e o est\xE1 removendo do Windows em favor do PowerShell e do JavaScript, mas grandes volumes de automa\xE7\xE3o .vbs ainda rodam em ambientes corporativos."
+    }
+  }
+};
+
 // src/languages/velocity.ts
 var velocity = {
   slug: "velocity",
@@ -13166,7 +14686,7 @@ var verse = {
     ecosystems: ["Unreal Engine", "Fortnite Creator"]
   },
   version: "UEFN Verse",
-  logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=Ve",
+  logo: "https://cdn.simpleicons.org/epicgames",
   color: "#111827",
   i18n: {
     en: {
@@ -13252,9 +14772,61 @@ var vhdl = {
   }
 };
 
+// src/languages/vimscript.ts
+var vimscript = {
+  slug: "vimscript",
+  aliases: ["vim", "vim script", "viml"],
+  publishedDate: "1991-11-02",
+  extensions: [".vim", ".vimrc", ".gvimrc"],
+  author: "Bram Moolenaar",
+  website: "https://www.vim.org",
+  paradigms: ["imperative", "scripting"],
+  tooling: {
+    runtimes: ["Vim", "Neovim"],
+    packageManagers: ["vim-plug", "lazy.nvim", "packer.nvim"],
+    ecosystems: ["Text Editors", "Scripting"]
+  },
+  version: "Vim 9.1",
+  logo: "https://cdn.simpleicons.org/vim/019733",
+  color: "#019733",
+  i18n: {
+    en: {
+      name: "Vim script",
+      description: "The scripting language built into the Vim editor for configuration & plugins.",
+      longDescription: "Vim script is the scripting language embedded in the Vim text editor. It drives user configuration through vimrc files and powers a large plugin ecosystem, with commands, autocommands, functions, and access to buffers, windows, and registers.\n\nVim 9 introduced Vim9 script, a faster, more structured dialect with typed variables and compiled functions, while Neovim pairs the legacy dialect with Lua as an alternative extension language."
+    },
+    es: {
+      name: "Vim script",
+      description: "El lenguaje de scripting integrado en el editor Vim para configuraci\xF3n y plugins.",
+      longDescription: "Vim script es el lenguaje de scripting integrado en el editor de texto Vim. Gestiona la configuraci\xF3n del usuario mediante archivos vimrc e impulsa un gran ecosistema de plugins, con comandos, autocomandos, funciones y acceso a buffers, ventanas y registros.\n\nVim 9 introdujo Vim9 script, un dialecto m\xE1s r\xE1pido y estructurado con variables tipadas y funciones compiladas, mientras que Neovim combina el dialecto cl\xE1sico con Lua como lenguaje de extensi\xF3n alternativo."
+    },
+    it: {
+      name: "Vim script",
+      description: "Il linguaggio di scripting integrato nell'editor Vim per configurazione e plugin.",
+      longDescription: "Vim script \xE8 il linguaggio di scripting incorporato nell'editor di testo Vim. Gestisce la configurazione dell'utente tramite i file vimrc e alimenta un vasto ecosistema di plugin, con comandi, autocomandi, funzioni e accesso a buffer, finestre e registri.\n\nVim 9 ha introdotto Vim9 script, un dialetto pi\xF9 veloce e strutturato con variabili tipate e funzioni compilate, mentre Neovim affianca al dialetto classico Lua come linguaggio di estensione alternativo."
+    },
+    fr: {
+      name: "Vim script",
+      description: "Le langage de script int\xE9gr\xE9 \xE0 l'\xE9diteur Vim pour la configuration et les plugins.",
+      longDescription: "Vim script est le langage de script int\xE9gr\xE9 \xE0 l'\xE9diteur de texte Vim. Il pilote la configuration de l'utilisateur via les fichiers vimrc et alimente un vaste \xE9cosyst\xE8me de plugins, avec des commandes, des autocommandes, des fonctions et un acc\xE8s aux tampons, fen\xEAtres et registres.\n\nVim 9 a introduit Vim9 script, un dialecte plus rapide et plus structur\xE9 avec des variables typ\xE9es et des fonctions compil\xE9es, tandis que Neovim associe le dialecte historique \xE0 Lua comme langage d'extension alternatif."
+    },
+    de: {
+      name: "Vim script",
+      description: "Die im Vim-Editor eingebaute Skriptsprache f\xFCr Konfiguration und Plugins.",
+      longDescription: "Vim script ist die in den Texteditor Vim eingebettete Skriptsprache. Sie steuert die Benutzerkonfiguration \xFCber vimrc-Dateien und treibt ein gro\xDFes Plugin-\xD6kosystem an, mit Befehlen, Autokommandos, Funktionen und Zugriff auf Puffer, Fenster und Register.\n\nVim 9 f\xFChrte Vim9 script ein, einen schnelleren, st\xE4rker strukturierten Dialekt mit typisierten Variablen und kompilierten Funktionen, w\xE4hrend Neovim den klassischen Dialekt mit Lua als alternativer Erweiterungssprache kombiniert."
+    },
+    pt: {
+      name: "Vim script",
+      description: "A linguagem de script embutida no editor Vim para configura\xE7\xE3o e plugins.",
+      longDescription: "Vim script \xE9 a linguagem de script embutida no editor de texto Vim. Ela controla a configura\xE7\xE3o do usu\xE1rio por meio de arquivos vimrc e move um grande ecossistema de plugins, com comandos, autocomandos, fun\xE7\xF5es e acesso a buffers, janelas e registradores.\n\nO Vim 9 introduziu o Vim9 script, um dialeto mais r\xE1pido e estruturado com vari\xE1veis tipadas e fun\xE7\xF5es compiladas, enquanto o Neovim combina o dialeto cl\xE1ssico com Lua como linguagem de extens\xE3o alternativa."
+    }
+  }
+};
+
 // src/languages/visual-basic.ts
 var visualBasic = {
   slug: "visual-basic",
+  aliases: ["vb", "vb.net"],
   publishedDate: "2001-02-13",
   extensions: [".vb"],
   author: "Microsoft",
@@ -13454,6 +15026,7 @@ var wdl = {
 // src/languages/webassembly.ts
 var webassembly = {
   slug: "webassembly",
+  aliases: ["wasm", "wat"],
   publishedDate: "2017-03-07",
   extensions: [".wasm", ".wat"],
   author: "W3C WebAssembly Community Group",
@@ -13842,6 +15415,58 @@ var xslt = {
   }
 };
 
+// src/languages/yacc.ts
+var yacc = {
+  slug: "yacc",
+  aliases: ["bison"],
+  publishedDate: "1973-01-01",
+  extensions: [".y", ".yacc"],
+  author: "Stephen C. Johnson (Bell Labs)",
+  website: "https://pubs.opengroup.org/onlinepubs/9699919799/utilities/yacc.html",
+  paradigms: ["declarative", "generator"],
+  tooling: {
+    runtimes: ["C toolchains"],
+    ecosystems: ["Compilers", "Language Tooling", "Unix"]
+  },
+  version: "POSIX yacc / Bison 3.8.2",
+  logo: "https://cdn.simpleicons.org/gnu/A42E2B",
+  color: "#4B6C4B",
+  i18n: {
+    en: {
+      name: "Yacc",
+      description: "A parser generator that turns context-free grammars into LALR parser code.",
+      longDescription: 'Yacc ("Yet Another Compiler-Compiler") is a classic Unix parser generator. A .y grammar file declares tokens, precedences, and production rules with embedded C actions, from which Yacc produces an LALR(1) parser that pairs naturally with a Lex-generated scanner.\n\nGNU Bison is the dominant modern implementation and remains widely used to build compilers, interpreters, configuration readers, and query languages across open-source projects.'
+    },
+    es: {
+      name: "Yacc",
+      description: "Un generador de parsers que convierte gram\xE1ticas libres de contexto en parsers LALR.",
+      longDescription: 'Yacc ("Yet Another Compiler-Compiler") es un generador de parsers cl\xE1sico de Unix. Un archivo de gram\xE1tica .y declara tokens, precedencias y reglas de producci\xF3n con acciones en C incrustadas, a partir de las cuales Yacc produce un parser LALR(1) que se combina de forma natural con un esc\xE1ner generado por Lex.\n\nGNU Bison es la implementaci\xF3n moderna dominante y sigue siendo muy usada para construir compiladores, int\xE9rpretes, lectores de configuraci\xF3n y lenguajes de consulta en proyectos de c\xF3digo abierto.'
+    },
+    it: {
+      name: "Yacc",
+      description: "Un generatore di parser che trasforma grammatiche libere dal contesto in parser LALR.",
+      longDescription: `Yacc ("Yet Another Compiler-Compiler") \xE8 un generatore di parser classico di Unix. Un file di grammatica .y dichiara token, precedenze e regole di produzione con azioni C incorporate, da cui Yacc produce un parser LALR(1) che si abbina naturalmente a uno scanner generato da Lex.
+
+GNU Bison \xE8 l'implementazione moderna dominante e rimane ampiamente usata per costruire compilatori, interpreti, lettori di configurazione e linguaggi di interrogazione nei progetti open source.`
+    },
+    fr: {
+      name: "Yacc",
+      description: "Un g\xE9n\xE9rateur de parseurs qui transforme des grammaires hors contexte en parseurs LALR.",
+      longDescription: "Yacc (\xAB Yet Another Compiler-Compiler \xBB) est un g\xE9n\xE9rateur de parseurs Unix classique. Un fichier de grammaire .y d\xE9clare des jetons, des pr\xE9c\xE9dences et des r\xE8gles de production avec des actions C int\xE9gr\xE9es, \xE0 partir desquelles Yacc produit un parseur LALR(1) qui se combine naturellement avec un scanner g\xE9n\xE9r\xE9 par Lex.\n\nGNU Bison est l'impl\xE9mentation moderne dominante et reste largement utilis\xE9e pour construire des compilateurs, des interpr\xE9teurs, des lecteurs de configuration et des langages de requ\xEAte dans les projets open source."
+    },
+    de: {
+      name: "Yacc",
+      description: "Ein Parser-Generator, der kontextfreie Grammatiken in LALR-Parser-Code \xFCbersetzt.",
+      longDescription: 'Yacc (\u201EYet Another Compiler-Compiler") ist ein klassischer Unix-Parser-Generator. Eine .y-Grammatikdatei deklariert Tokens, Pr\xE4zedenzen und Produktionsregeln mit eingebetteten C-Aktionen, aus denen Yacc einen LALR(1)-Parser erzeugt, der sich nat\xFCrlich mit einem von Lex erzeugten Scanner kombinieren l\xE4sst.\n\nGNU Bison ist die dominierende moderne Implementierung und wird weiterhin breit eingesetzt, um Compiler, Interpreter, Konfigurationsleser und Abfragesprachen in Open-Source-Projekten zu bauen.'
+    },
+    pt: {
+      name: "Yacc",
+      description: "Um gerador de parsers que converte gram\xE1ticas livres de contexto em parsers LALR.",
+      longDescription: 'Yacc ("Yet Another Compiler-Compiler") \xE9 um gerador de parsers cl\xE1ssico do Unix. Um arquivo de gram\xE1tica .y declara tokens, preced\xEAncias e regras de produ\xE7\xE3o com a\xE7\xF5es em C embutidas, a partir das quais o Yacc produz um parser LALR(1) que combina naturalmente com um scanner gerado pelo Lex.\n\nO GNU Bison \xE9 a implementa\xE7\xE3o moderna dominante e continua amplamente usado para construir compiladores, interpretadores, leitores de configura\xE7\xE3o e linguagens de consulta em projetos de c\xF3digo aberto.'
+    }
+  }
+};
+
 // src/languages/yaml.ts
 var yaml = {
   slug: "yaml",
@@ -14143,43 +15768,46 @@ var languages = [
   ada,
   agda,
   algol,
+  alloy,
   ampl,
+  angelscript,
   ante,
   antlr,
   apex,
   apl,
   applescript,
-  arduino,
   aql,
+  arduino,
   asciidoc,
   asp,
   assembly,
   assemblyscript,
-  angelscript,
   astro,
   austral,
   autohotkey,
   avroIdl,
   awk,
   ballerina,
-  basic,
   bash,
+  basic,
   batch,
   bazel,
   bcpl,
-  bicep,
   bibtex,
+  bicep,
   blade,
   bosque,
   bqn,
   brainfuck,
   c,
+  c3,
   cairo,
   capnproto,
   carbon,
   cel,
   chapel,
   circom,
+  clarity,
   clojure,
   cmake,
   cobol,
@@ -14187,13 +15815,14 @@ var languages = [
   coldfusion,
   coq,
   cpp,
-  crystal,
   cql,
+  crystal,
   csharp,
   css,
   cuda,
   cue,
   curry,
+  cwl,
   cypher,
   cython,
   d,
@@ -14205,32 +15834,37 @@ var languages = [
   dockerfile,
   dot,
   earthly,
+  edgeql,
   editorconfig,
   eiffel,
   ejs,
   elixir,
   elm,
+  emacsLisp,
   erb,
   erlang,
   factor,
+  faust,
   fe,
   fennel,
   fish,
   flatbuffers,
+  flix,
   flux,
   forth,
   fortran,
-  freemarker,
   fql,
+  freemarker,
   fsharp,
   fstar,
-  gdscript,
+  futhark,
   gcode,
+  gdscript,
   gettext,
   git,
   gleam,
-  gml,
   glsl,
+  gml,
   go,
   gradle,
   grain,
@@ -14254,11 +15888,14 @@ var languages = [
   inkNarrative,
   io,
   isabelle,
+  j,
   janet,
   java,
   javascript,
+  jcl,
   jinja,
   jmespath,
+  jq,
   json,
   json5,
   jsonata,
@@ -14274,9 +15911,10 @@ var languages = [
   kql,
   lean,
   less,
+  lex,
   ligo,
-  liquid,
   linkerscript,
+  liquid,
   lisp,
   llvmIr,
   lobster,
@@ -14291,13 +15929,13 @@ var languages = [
   matlab,
   maxima,
   mdx,
+  mercury,
   mermaid,
   meson,
-  mercury,
   metal,
   modelica,
-  mojo,
   modula2,
+  mojo,
   moonbit,
   move,
   mumps,
@@ -14308,12 +15946,13 @@ var languages = [
   nickel,
   nim,
   nix,
+  noir,
   nunjucks,
   nushell,
+  oberon,
   objectiveC,
   ocaml,
   octave,
-  oberon,
   odin,
   openapi,
   opencl,
@@ -14323,8 +15962,8 @@ var languages = [
   perl,
   php,
   pineScript,
-  plI,
   pkl,
+  plI,
   plantuml,
   plpgsql,
   plsql,
@@ -14336,24 +15975,29 @@ var languages = [
   processing,
   prolog,
   promql,
+  properties,
   protobuf,
+  prql,
   pug,
   puppet,
   purescript,
   python,
-  qml,
+  q,
   qmake,
+  qml,
   qsharp,
   r,
   racket,
   raku,
   razor,
+  reasonml,
   rebol,
   red,
-  reasonml,
   rego,
+  renpy,
   rescript,
   restructuredtext,
+  rexx,
   roc,
   rpg,
   ruby,
@@ -14364,14 +16008,16 @@ var languages = [
   scss,
   self,
   simula,
+  slang,
   smalltalk,
   smarty,
+  smithy,
   snakemake,
   snobol,
   solidity,
   soql,
-  sparql,
   spark,
+  sparql,
   spl,
   spss,
   sql,
@@ -14380,9 +16026,11 @@ var languages = [
   starlark,
   stata,
   stylus,
+  supercollider,
   svelte,
   svg,
   svn,
+  sway,
   swift,
   tcl,
   tcsh,
@@ -14396,21 +16044,24 @@ var languages = [
   twee,
   twig,
   typescript,
+  typespec,
   typst,
   unison,
   v,
   vala,
-  vba,
   vale,
+  vba,
+  vbscript,
   velocity,
   verilog,
   verse,
   vhdl,
+  vimscript,
   visualBasic,
   vue,
   vyper,
-  webassembly,
   wdl,
+  webassembly,
   wgsl,
   wren,
   xaml,
@@ -14418,6 +16069,7 @@ var languages = [
   xpath,
   xquery,
   xslt,
+  yacc,
   yaml,
   yara,
   zeek,
@@ -14426,37 +16078,14 @@ var languages = [
   zsh
 ];
 
-// src/domain/detection/match.ts
-var pathSegmentPattern = /[/\\]/;
-var getBasename = (filename) => {
-  const parts = filename.trim().split(pathSegmentPattern);
-  return parts.at(-1).toLowerCase();
-};
-var matchesExtension = (basename, extension) => {
-  const normalizedExtension = extension.toLowerCase();
-  if (normalizedExtension.startsWith(".")) {
-    return basename.endsWith(normalizedExtension);
-  }
-  return basename === normalizedExtension || basename.endsWith(`.${normalizedExtension}`);
-};
-var detectMatchingEntries = (entries, filename) => {
-  const basename = getBasename(filename);
-  if (!basename) {
-    return [];
-  }
-  return entries.map((entry, index) => ({
-    entry,
-    index,
-    matchLength: Math.max(
-      ...entry.extensions.filter((extension) => matchesExtension(basename, extension)).map((extension) => extension.length)
-    )
-  })).filter(({ matchLength }) => Number.isFinite(matchLength)).sort((first, second) => second.matchLength - first.matchLength || first.index - second.index).map(({ entry }) => entry);
-};
-
 // src/domain/detection/detect.ts
 var detectLanguages = (filename) => {
   return detectMatchingEntries(languages, filename);
 };
 var detectLanguage = (filename) => detectLanguages(filename).at(0);
+var detectLanguageByShebang = (content) => {
+  const slug = detectLanguageSlugByShebang(content);
+  return slug ? languages.find((language) => language.slug === slug) : void 0;
+};
 
-export { detectLanguage, detectLanguages };
+export { detectLanguage, detectLanguageByShebang, detectLanguageSlugByShebang, detectLanguages };