code-languages 1.41.0 → 1.42.1

package/dist/api.js

@@ -80,7 +80,7 @@ var init_actionscript = __esm({
       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"],
@@ -264,7 +264,7 @@ var init_algol = __esm({
         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: {
@@ -302,6 +302,64 @@ var init_algol = __esm({
   }
 });
 
+// src/languages/alloy.ts
+var alloy_exports = {};
+__export(alloy_exports, {
+  alloy: () => alloy
+});
+var alloy;
+var init_alloy = __esm({
+  "src/languages/alloy.ts"() {
+    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_exports = {};
 __export(ampl_exports, {
@@ -380,7 +438,7 @@ var init_angelscript = __esm({
         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: {
@@ -1022,6 +1080,9 @@ var init_assemblyscript = __esm({
       author: "Daniel Wirtz / AssemblyScript Contributors",
       website: "https://www.assemblyscript.org",
       paradigms: ["imperative", "object-oriented", "compiled"],
+      relations: {
+        compilesTo: ["webassembly"]
+      },
       tooling: {
         runtimes: ["Wasm", "WASI"],
         ecosystems: ["WebAssembly"]
@@ -1668,7 +1729,7 @@ var init_bcpl = __esm({
         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: {
@@ -1903,7 +1964,7 @@ var init_bosque = __esm({
         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: {
@@ -2019,7 +2080,7 @@ var init_brainfuck = __esm({
         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: {
@@ -2116,6 +2177,68 @@ var init_c = __esm({
   }
 });
 
+// src/languages/c3.ts
+var c3_exports = {};
+__export(c3_exports, {
+  c3: () => c3
+});
+var c3;
+var init_c3 = __esm({
+  "src/languages/c3.ts"() {
+    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_exports = {};
 __export(cairo_exports, {
@@ -2469,6 +2592,68 @@ var init_circom = __esm({
   }
 });
 
+// src/languages/clarity.ts
+var clarity_exports = {};
+__export(clarity_exports, {
+  clarity: () => clarity
+});
+var clarity;
+var init_clarity = __esm({
+  "src/languages/clarity.ts"() {
+    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_exports = {};
 __export(clojure_exports, {
@@ -2606,7 +2791,7 @@ var init_cobol = __esm({
         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: {
@@ -2659,6 +2844,9 @@ var init_coffeescript = __esm({
       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"],
@@ -2838,6 +3026,9 @@ var init_cpp = __esm({
       author: "Bjarne Stroustrup",
       website: "https://isocpp.org",
       paradigms: ["procedural", "object-oriented", "generic", "functional"],
+      relations: {
+        supersetOf: ["c"]
+      },
       tooling: {
         runtimes: ["Native"],
         packageManagers: ["Conan", "vcpkg"],
@@ -3290,6 +3481,64 @@ var init_curry = __esm({
   }
 });
 
+// src/languages/cwl.ts
+var cwl_exports = {};
+__export(cwl_exports, {
+  cwl: () => cwl
+});
+var cwl;
+var init_cwl = __esm({
+  "src/languages/cwl.ts"() {
+    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_exports = {};
 __export(cypher_exports, {
@@ -3363,6 +3612,10 @@ var init_cython = __esm({
       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"],
@@ -3540,6 +3793,9 @@ var init_dart = __esm({
       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"],
@@ -3940,6 +4196,65 @@ var init_earthly = __esm({
   }
 });
 
+// src/languages/edgeql.ts
+var edgeql_exports = {};
+__export(edgeql_exports, {
+  edgeql: () => edgeql
+});
+var edgeql;
+var init_edgeql = __esm({
+  "src/languages/edgeql.ts"() {
+    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_exports = {};
 __export(editorconfig_exports, {
@@ -4189,6 +4504,9 @@ var init_elm = __esm({
       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"],
@@ -4249,6 +4567,9 @@ var init_emacs_lisp = __esm({
       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"],
@@ -4306,7 +4627,7 @@ var init_erb = __esm({
       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"],
@@ -4470,6 +4791,67 @@ var init_factor = __esm({
   }
 });
 
+// src/languages/faust.ts
+var faust_exports = {};
+__export(faust_exports, {
+  faust: () => faust
+});
+var faust;
+var init_faust = __esm({
+  "src/languages/faust.ts"() {
+    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_exports = {};
 __export(fe_exports, {
@@ -4544,6 +4926,9 @@ var init_fennel = __esm({
       author: "Calvin Rose, Phil Hagelberg",
       website: "https://fennel-lang.org",
       paradigms: ["functional", "lisp", "scripting", "metaprogramming"],
+      relations: {
+        compilesTo: ["lua"]
+      },
       tooling: {
         runtimes: ["Lua", "LuaJIT"],
         packageManagers: ["LuaRocks"],
@@ -4705,6 +5090,65 @@ var init_flatbuffers = __esm({
   }
 });
 
+// src/languages/flix.ts
+var flix_exports = {};
+__export(flix_exports, {
+  flix: () => flix
+});
+var flix;
+var init_flix = __esm({
+  "src/languages/flix.ts"() {
+    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_exports = {};
 __export(flux_exports, {
@@ -4893,7 +5337,7 @@ var init_fql = __esm({
       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"],
@@ -5116,6 +5560,68 @@ var init_fstar = __esm({
   }
 });
 
+// src/languages/futhark.ts
+var futhark_exports = {};
+__export(futhark_exports, {
+  futhark: () => futhark
+});
+var futhark;
+var init_futhark = __esm({
+  "src/languages/futhark.ts"() {
+    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_exports = {};
 __export(gcode_exports, {
@@ -5364,6 +5870,9 @@ var init_gleam = __esm({
       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"],
@@ -5892,8 +6401,11 @@ var init_hack = __esm({
       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"],
@@ -6189,6 +6701,9 @@ var init_haxe = __esm({
       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"],
@@ -6370,7 +6885,7 @@ var init_hocon = __esm({
         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: {
@@ -6870,6 +7385,64 @@ var init_isabelle = __esm({
   }
 });
 
+// src/languages/j.ts
+var j_exports = {};
+__export(j_exports, {
+  j: () => j
+});
+var j;
+var init_j = __esm({
+  "src/languages/j.ts"() {
+    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_exports = {};
 __export(janet_exports, {
@@ -7350,6 +7923,9 @@ var init_json5 = __esm({
       author: "Aseem Kishore",
       website: "https://json5.org",
       paradigms: ["declarative"],
+      relations: {
+        supersetOf: ["json"]
+      },
       tooling: {
         runtimes: ["Node.js", "Browser"],
         packageManagers: ["npm", "pnpm", "Yarn"],
@@ -7467,6 +8043,9 @@ var init_jsonc = __esm({
       author: "Microsoft",
       website: "https://jsonc.org",
       paradigms: ["data serialization", "configuration"],
+      relations: {
+        supersetOf: ["json"]
+      },
       tooling: {
         runtimes: ["Editors", "Build tools"],
         ecosystems: ["JavaScript", "TypeScript", "Configuration"]
@@ -8114,6 +8693,10 @@ var init_less = __esm({
       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"],
@@ -8179,7 +8762,7 @@ var init_lex = __esm({
         ecosystems: ["Compilers", "Language Tooling", "Unix"]
       },
       version: "POSIX lex / flex 2.6.4",
-      logo: "https://dummyimage.com/32x32/DBCA00/000000.png&text=Lex",
+      logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/lex.svg",
       color: "#DBCA00",
       i18n: {
         en: {
@@ -8701,6 +9284,9 @@ var init_luau = __esm({
       author: "Roblox",
       website: "https://luau.org",
       paradigms: ["imperative", "scripting", "gradually typed", "embeddable"],
+      relations: {
+        supersetOf: ["lua"]
+      },
       tooling: {
         runtimes: ["Luau VM", "Roblox"],
         packageManagers: ["Wally", "Pesde"],
@@ -9165,6 +9751,9 @@ var init_mdx = __esm({
       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"],
@@ -9522,7 +10111,7 @@ var init_modula_2 = __esm({
         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: {
@@ -10098,6 +10687,9 @@ var init_nim = __esm({
       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"],
@@ -10201,6 +10793,66 @@ var init_nix = __esm({
   }
 });
 
+// src/languages/noir.ts
+var noir_exports = {};
+__export(noir_exports, {
+  noir: () => noir
+});
+var noir;
+var init_noir = __esm({
+  "src/languages/noir.ts"() {
+    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_exports = {};
 __export(nunjucks_exports, {
@@ -10280,7 +10932,7 @@ var init_nushell = __esm({
         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: {
@@ -10339,7 +10991,7 @@ var init_oberon = __esm({
         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: {
@@ -10393,6 +11045,9 @@ var init_objective_c = __esm({
       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"],
@@ -11271,6 +11926,9 @@ var init_plpgsql = __esm({
       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"]
@@ -11329,6 +11987,9 @@ var init_plsql = __esm({
       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"]
@@ -11957,6 +12618,68 @@ var init_protobuf = __esm({
   }
 });
 
+// src/languages/prql.ts
+var prql_exports = {};
+__export(prql_exports, {
+  prql: () => prql
+});
+var prql;
+var init_prql = __esm({
+  "src/languages/prql.ts"() {
+    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_exports = {};
 __export(pug_exports, {
@@ -12090,6 +12813,9 @@ var init_purescript = __esm({
       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"],
@@ -12194,6 +12920,65 @@ var init_python = __esm({
   }
 });
 
+// src/languages/q.ts
+var q_exports = {};
+__export(q_exports, {
+  q: () => q
+});
+var q;
+var init_q = __esm({
+  "src/languages/q.ts"() {
+    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_exports = {};
 __export(qmake_exports, {
@@ -12622,6 +13407,9 @@ var init_reasonml = __esm({
       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"],
@@ -12841,6 +13629,65 @@ var init_rego = __esm({
   }
 });
 
+// src/languages/renpy.ts
+var renpy_exports = {};
+__export(renpy_exports, {
+  renpy: () => renpy
+});
+var renpy;
+var init_renpy = __esm({
+  "src/languages/renpy.ts"() {
+    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_exports = {};
 __export(rescript_exports, {
@@ -12856,6 +13703,9 @@ var init_rescript = __esm({
       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"],
@@ -13443,6 +14293,10 @@ var init_scss = __esm({
       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"],
@@ -13566,7 +14420,7 @@ var init_simula = __esm({
         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: {
@@ -13604,6 +14458,67 @@ var init_simula = __esm({
   }
 });
 
+// src/languages/slang.ts
+var slang_exports = {};
+__export(slang_exports, {
+  slang: () => slang
+});
+var slang;
+var init_slang = __esm({
+  "src/languages/slang.ts"() {
+    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_exports = {};
 __export(smalltalk_exports, {
@@ -13721,6 +14636,65 @@ var init_smarty = __esm({
   }
 });
 
+// src/languages/smithy.ts
+var smithy_exports = {};
+__export(smithy_exports, {
+  smithy: () => smithy
+});
+var smithy;
+var init_smithy = __esm({
+  "src/languages/smithy.ts"() {
+    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_exports = {};
 __export(snakemake_exports, {
@@ -13800,7 +14774,7 @@ var init_snobol = __esm({
         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: {
@@ -14489,6 +15463,10 @@ var init_stylus = __esm({
       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"],
@@ -14533,6 +15511,66 @@ var init_stylus = __esm({
   }
 });
 
+// src/languages/supercollider.ts
+var supercollider_exports = {};
+__export(supercollider_exports, {
+  supercollider: () => supercollider
+});
+var supercollider;
+var init_supercollider = __esm({
+  "src/languages/supercollider.ts"() {
+    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_exports = {};
 __export(svelte_exports, {
@@ -14548,6 +15586,9 @@ var init_svelte = __esm({
       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"],
@@ -14708,6 +15749,66 @@ var init_svn = __esm({
   }
 });
 
+// src/languages/sway.ts
+var sway_exports = {};
+__export(sway_exports, {
+  sway: () => sway
+});
+var sway;
+var init_sway = __esm({
+  "src/languages/sway.ts"() {
+    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_exports = {};
 __export(swift_exports, {
@@ -14846,7 +15947,7 @@ var init_tcsh = __esm({
         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: {
@@ -15245,6 +16346,9 @@ var init_tsql = __esm({
       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",
@@ -15426,6 +16530,10 @@ var init_typescript = __esm({
       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"],
@@ -15470,6 +16578,69 @@ var init_typescript = __esm({
   }
 });
 
+// src/languages/typespec.ts
+var typespec_exports = {};
+__export(typespec_exports, {
+  typespec: () => typespec
+});
+var typespec;
+var init_typespec = __esm({
+  "src/languages/typespec.ts"() {
+    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_exports = {};
 __export(typst_exports, {
@@ -15603,6 +16774,9 @@ var init_v = __esm({
       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"],
@@ -15780,6 +16954,9 @@ var init_vba = __esm({
       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"]
       },
@@ -15838,12 +17015,15 @@ var init_vbscript = __esm({
       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://dummyimage.com/32x32/15DCDC/000000.png&text=VBS",
+      logo: "https://raw.githubusercontent.com/ElJijuna/code-languages/main/public/assets/placeholders/vbscript.svg",
       color: "#15DCDC",
       i18n: {
         en: {
@@ -17245,7 +18425,7 @@ var init_zsh = __esm({
         packageManagers: ["Homebrew", "APT", "DNF", "Pacman"],
         ecosystems: ["Unix", "Linux", "macOS", "DevOps"]
       },
-      version: "5.9.1",
+      version: "5.9.2",
       logo: "https://commons.wikimedia.org/wiki/Special:Redirect/file/Z_Shell_Logo_Color_Horizontal.svg",
       color: "#89E051",
       i18n: {
@@ -17429,6 +18609,7 @@ var languageIndex = [
   { slug: "ada", extensions: [".adb", ".ads", ".ada"] },
   { slug: "agda", extensions: [".agda", ".lagda", ".lagda.md", ".lagda.rst", ".lagda.tex"] },
   { slug: "algol", extensions: [".alg", ".algol"] },
+  { slug: "alloy", extensions: [".als"] },
   { slug: "ampl", extensions: [".mod", ".dat", ".run"] },
   { slug: "angelscript", extensions: [".as", ".angelscript"] },
   { slug: "ante", extensions: [".ante"] },
@@ -17463,12 +18644,14 @@ var languageIndex = [
   { slug: "bqn", extensions: [".bqn"] },
   { slug: "brainfuck", extensions: [".bf", ".b"] },
   { slug: "c", extensions: [".c", ".h"] },
+  { slug: "c3", extensions: [".c3", ".c3i"] },
   { slug: "cairo", extensions: [".cairo"] },
   { slug: "capnproto", extensions: [".capnp"] },
   { slug: "carbon", extensions: [".carbon"] },
   { slug: "cel", extensions: [".cel"] },
   { slug: "chapel", extensions: [".chpl"] },
   { slug: "circom", extensions: [".circom"] },
+  { slug: "clarity", extensions: [".clar"] },
   { slug: "clojure", extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"] },
   { slug: "cmake", extensions: ["CMakeLists.txt", ".cmake"] },
   { slug: "cobol", extensions: [".cob", ".cbl", ".cobol", ".cpy"] },
@@ -17483,6 +18666,7 @@ var languageIndex = [
   { slug: "cuda", extensions: [".cu", ".cuh"] },
   { slug: "cue", extensions: [".cue"] },
   { slug: "curry", extensions: [".curry", ".lcurry"] },
+  { slug: "cwl", extensions: [".cwl"] },
   { slug: "cypher", extensions: [".cypher", ".cyp"] },
   { slug: "cython", extensions: [".pyx", ".pxd", ".pxi"] },
   { slug: "d", extensions: [".d", ".di"] },
@@ -17494,6 +18678,7 @@ var languageIndex = [
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
   { slug: "dot", extensions: [".dot", ".gv"] },
   { slug: "earthly", extensions: ["Earthfile"] },
+  { slug: "edgeql", extensions: [".edgeql"] },
   { slug: "editorconfig", extensions: [".editorconfig"] },
   { slug: "eiffel", extensions: [".e"] },
   { slug: "ejs", extensions: [".ejs"] },
@@ -17506,10 +18691,12 @@ var languageIndex = [
     extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"]
   },
   { slug: "factor", extensions: [".factor"] },
+  { slug: "faust", extensions: [".dsp"] },
   { slug: "fe", extensions: [".fe"] },
   { slug: "fennel", extensions: [".fnl"] },
   { slug: "fish", extensions: [".fish"] },
   { slug: "flatbuffers", extensions: [".fbs"] },
+  { slug: "flix", extensions: [".flix"] },
   { slug: "flux", extensions: [".flux"] },
   { slug: "forth", extensions: [".fs", ".fth", ".forth", ".4th"] },
   {
@@ -17520,6 +18707,7 @@ var languageIndex = [
   { slug: "freemarker", extensions: [".ftl", ".ftlh", ".ftlx"] },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
   { slug: "fstar", extensions: [".fst", ".fsti"] },
+  { slug: "futhark", extensions: [".fut"] },
   { slug: "gcode", extensions: [".gcode", ".gco", ".nc", ".cnc", ".tap"] },
   { slug: "gdscript", extensions: [".gd"] },
   { slug: "gettext", extensions: [".po", ".pot"] },
@@ -17553,6 +18741,7 @@ var languageIndex = [
   { slug: "ink-narrative", extensions: [".ink"] },
   { slug: "io", extensions: [".io"] },
   { slug: "isabelle", extensions: [".thy"] },
+  { slug: "j", extensions: [".ijs"] },
   { slug: "janet", extensions: [".janet", ".jdn"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
@@ -17610,6 +18799,7 @@ var languageIndex = [
   { slug: "nickel", extensions: [".ncl"] },
   { slug: "nim", extensions: [".nim", ".nims", ".nimble"] },
   { slug: "nix", extensions: [".nix"] },
+  { slug: "noir", extensions: [".nr"] },
   { slug: "nunjucks", extensions: [".njk", ".nunjucks"] },
   { slug: "nushell", extensions: [".nu"] },
   { slug: "oberon", extensions: [".ob", ".mod"] },
@@ -17640,10 +18830,12 @@ var languageIndex = [
   { slug: "promql", extensions: [".promql"] },
   { slug: "properties", extensions: [".properties"] },
   { slug: "protobuf", extensions: [".proto"] },
+  { slug: "prql", extensions: [".prql"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
   { slug: "puppet", extensions: [".pp", ".epp"] },
   { slug: "purescript", extensions: [".purs"] },
   { slug: "python", extensions: [".py", ".pyw"] },
+  { slug: "q", extensions: [".q", ".k"] },
   { slug: "qmake", extensions: [".pri", ".prf"] },
   { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
   { slug: "qsharp", extensions: [".qs"] },
@@ -17655,6 +18847,7 @@ var languageIndex = [
   { slug: "rebol", extensions: [".r", ".reb", ".rebol"] },
   { slug: "red", extensions: [".red", ".reds"] },
   { slug: "rego", extensions: [".rego"] },
+  { slug: "renpy", extensions: [".rpy", ".rpym"] },
   { slug: "rescript", extensions: [".res", ".resi"] },
   { slug: "restructuredtext", extensions: [".rst", ".rest"] },
   { slug: "rexx", extensions: [".rexx", ".rex"] },
@@ -17671,8 +18864,10 @@ var languageIndex = [
   { slug: "scss", extensions: [".scss", ".sass"] },
   { slug: "self", extensions: [".self"] },
   { slug: "simula", extensions: [".sim", ".simula"] },
+  { slug: "slang", extensions: [".slang"] },
   { slug: "smalltalk", extensions: [".st"] },
   { slug: "smarty", extensions: [".tpl", ".smarty"] },
+  { slug: "smithy", extensions: [".smithy"] },
   { slug: "snakemake", extensions: [".smk", "Snakefile"] },
   { slug: "snobol", extensions: [".sno", ".snobol"] },
   { slug: "solidity", extensions: [".sol"] },
@@ -17687,9 +18882,11 @@ var languageIndex = [
   { slug: "starlark", extensions: [".bzl", ".star", ".sky"] },
   { slug: "stata", extensions: [".do", ".ado", ".mata"] },
   { slug: "stylus", extensions: [".styl"] },
+  { slug: "supercollider", extensions: [".scd", ".sc"] },
   { slug: "svelte", extensions: [".svelte"] },
   { slug: "svg", extensions: [".svg", ".svgz"] },
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
+  { slug: "sway", extensions: [".sw"] },
   { slug: "swift", extensions: [".swift"] },
   { slug: "tcl", extensions: [".tcl", ".tm", ".test"] },
   { slug: "tcsh", extensions: [".tcsh", ".csh", ".tcshrc", ".cshrc"] },
@@ -17703,6 +18900,7 @@ var languageIndex = [
   { slug: "twee", extensions: [".tw", ".twee", ".tw2"] },
   { slug: "twig", extensions: [".twig"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
+  { slug: "typespec", extensions: [".tsp"] },
   { slug: "typst", extensions: [".typ"] },
   { slug: "unison", extensions: [".u", ".uu"] },
   { slug: "v", extensions: [".v", ".vsh"] },
@@ -17744,6 +18942,7 @@ var languageLoaders = {
   ada: async () => (await Promise.resolve().then(() => (init_ada(), ada_exports))).ada,
   agda: async () => (await Promise.resolve().then(() => (init_agda(), agda_exports))).agda,
   algol: async () => (await Promise.resolve().then(() => (init_algol(), algol_exports))).algol,
+  alloy: async () => (await Promise.resolve().then(() => (init_alloy(), alloy_exports))).alloy,
   ampl: async () => (await Promise.resolve().then(() => (init_ampl(), ampl_exports))).ampl,
   angelscript: async () => (await Promise.resolve().then(() => (init_angelscript(), angelscript_exports))).angelscript,
   ante: async () => (await Promise.resolve().then(() => (init_ante(), ante_exports))).ante,
@@ -17775,12 +18974,14 @@ var languageLoaders = {
   bqn: async () => (await Promise.resolve().then(() => (init_bqn(), bqn_exports))).bqn,
   brainfuck: async () => (await Promise.resolve().then(() => (init_brainfuck(), brainfuck_exports))).brainfuck,
   c: async () => (await Promise.resolve().then(() => (init_c(), c_exports))).c,
+  c3: async () => (await Promise.resolve().then(() => (init_c3(), c3_exports))).c3,
   cairo: async () => (await Promise.resolve().then(() => (init_cairo(), cairo_exports))).cairo,
   capnproto: async () => (await Promise.resolve().then(() => (init_capnproto(), capnproto_exports))).capnproto,
   carbon: async () => (await Promise.resolve().then(() => (init_carbon(), carbon_exports))).carbon,
   cel: async () => (await Promise.resolve().then(() => (init_cel(), cel_exports))).cel,
   chapel: async () => (await Promise.resolve().then(() => (init_chapel(), chapel_exports))).chapel,
   circom: async () => (await Promise.resolve().then(() => (init_circom(), circom_exports))).circom,
+  clarity: async () => (await Promise.resolve().then(() => (init_clarity(), clarity_exports))).clarity,
   clojure: async () => (await Promise.resolve().then(() => (init_clojure(), clojure_exports))).clojure,
   cmake: async () => (await Promise.resolve().then(() => (init_cmake(), cmake_exports))).cmake,
   cobol: async () => (await Promise.resolve().then(() => (init_cobol(), cobol_exports))).cobol,
@@ -17795,6 +18996,7 @@ var languageLoaders = {
   cuda: async () => (await Promise.resolve().then(() => (init_cuda(), cuda_exports))).cuda,
   cue: async () => (await Promise.resolve().then(() => (init_cue(), cue_exports))).cue,
   curry: async () => (await Promise.resolve().then(() => (init_curry(), curry_exports))).curry,
+  cwl: async () => (await Promise.resolve().then(() => (init_cwl(), cwl_exports))).cwl,
   cypher: async () => (await Promise.resolve().then(() => (init_cypher(), cypher_exports))).cypher,
   cython: async () => (await Promise.resolve().then(() => (init_cython(), cython_exports))).cython,
   d: async () => (await Promise.resolve().then(() => (init_d(), d_exports))).d,
@@ -17806,6 +19008,7 @@ var languageLoaders = {
   dockerfile: async () => (await Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports))).dockerfile,
   dot: async () => (await Promise.resolve().then(() => (init_dot(), dot_exports))).dot,
   earthly: async () => (await Promise.resolve().then(() => (init_earthly(), earthly_exports))).earthly,
+  edgeql: async () => (await Promise.resolve().then(() => (init_edgeql(), edgeql_exports))).edgeql,
   editorconfig: async () => (await Promise.resolve().then(() => (init_editorconfig(), editorconfig_exports))).editorconfig,
   eiffel: async () => (await Promise.resolve().then(() => (init_eiffel(), eiffel_exports))).eiffel,
   ejs: async () => (await Promise.resolve().then(() => (init_ejs(), ejs_exports))).ejs,
@@ -17815,10 +19018,12 @@ var languageLoaders = {
   erb: async () => (await Promise.resolve().then(() => (init_erb(), erb_exports))).erb,
   erlang: async () => (await Promise.resolve().then(() => (init_erlang(), erlang_exports))).erlang,
   factor: async () => (await Promise.resolve().then(() => (init_factor(), factor_exports))).factor,
+  faust: async () => (await Promise.resolve().then(() => (init_faust(), faust_exports))).faust,
   fe: async () => (await Promise.resolve().then(() => (init_fe(), fe_exports))).fe,
   fennel: async () => (await Promise.resolve().then(() => (init_fennel(), fennel_exports))).fennel,
   fish: async () => (await Promise.resolve().then(() => (init_fish(), fish_exports))).fish,
   flatbuffers: async () => (await Promise.resolve().then(() => (init_flatbuffers(), flatbuffers_exports))).flatbuffers,
+  flix: async () => (await Promise.resolve().then(() => (init_flix(), flix_exports))).flix,
   flux: async () => (await Promise.resolve().then(() => (init_flux(), flux_exports))).flux,
   forth: async () => (await Promise.resolve().then(() => (init_forth(), forth_exports))).forth,
   fortran: async () => (await Promise.resolve().then(() => (init_fortran(), fortran_exports))).fortran,
@@ -17826,6 +19031,7 @@ var languageLoaders = {
   freemarker: async () => (await Promise.resolve().then(() => (init_freemarker(), freemarker_exports))).freemarker,
   fsharp: async () => (await Promise.resolve().then(() => (init_fsharp(), fsharp_exports))).fsharp,
   fstar: async () => (await Promise.resolve().then(() => (init_fstar(), fstar_exports))).fstar,
+  futhark: async () => (await Promise.resolve().then(() => (init_futhark(), futhark_exports))).futhark,
   gcode: async () => (await Promise.resolve().then(() => (init_gcode(), gcode_exports))).gcode,
   gdscript: async () => (await Promise.resolve().then(() => (init_gdscript(), gdscript_exports))).gdscript,
   gettext: async () => (await Promise.resolve().then(() => (init_gettext(), gettext_exports))).gettext,
@@ -17856,6 +19062,7 @@ var languageLoaders = {
   "ink-narrative": async () => (await Promise.resolve().then(() => (init_ink_narrative(), ink_narrative_exports))).inkNarrative,
   io: async () => (await Promise.resolve().then(() => (init_io(), io_exports))).io,
   isabelle: async () => (await Promise.resolve().then(() => (init_isabelle(), isabelle_exports))).isabelle,
+  j: async () => (await Promise.resolve().then(() => (init_j(), j_exports))).j,
   janet: async () => (await Promise.resolve().then(() => (init_janet(), janet_exports))).janet,
   java: async () => (await Promise.resolve().then(() => (init_java(), java_exports))).java,
   javascript: async () => (await Promise.resolve().then(() => (init_javascript(), javascript_exports))).javascript,
@@ -17913,6 +19120,7 @@ var languageLoaders = {
   nickel: async () => (await Promise.resolve().then(() => (init_nickel(), nickel_exports))).nickel,
   nim: async () => (await Promise.resolve().then(() => (init_nim(), nim_exports))).nim,
   nix: async () => (await Promise.resolve().then(() => (init_nix(), nix_exports))).nix,
+  noir: async () => (await Promise.resolve().then(() => (init_noir(), noir_exports))).noir,
   nunjucks: async () => (await Promise.resolve().then(() => (init_nunjucks(), nunjucks_exports))).nunjucks,
   nushell: async () => (await Promise.resolve().then(() => (init_nushell(), nushell_exports))).nushell,
   oberon: async () => (await Promise.resolve().then(() => (init_oberon(), oberon_exports))).oberon,
@@ -17943,10 +19151,12 @@ var languageLoaders = {
   promql: async () => (await Promise.resolve().then(() => (init_promql(), promql_exports))).promql,
   properties: async () => (await Promise.resolve().then(() => (init_properties(), properties_exports))).properties,
   protobuf: async () => (await Promise.resolve().then(() => (init_protobuf(), protobuf_exports))).protobuf,
+  prql: async () => (await Promise.resolve().then(() => (init_prql(), prql_exports))).prql,
   pug: async () => (await Promise.resolve().then(() => (init_pug(), pug_exports))).pug,
   puppet: async () => (await Promise.resolve().then(() => (init_puppet(), puppet_exports))).puppet,
   purescript: async () => (await Promise.resolve().then(() => (init_purescript(), purescript_exports))).purescript,
   python: async () => (await Promise.resolve().then(() => (init_python(), python_exports))).python,
+  q: async () => (await Promise.resolve().then(() => (init_q(), q_exports))).q,
   qmake: async () => (await Promise.resolve().then(() => (init_qmake(), qmake_exports))).qmake,
   qml: async () => (await Promise.resolve().then(() => (init_qml(), qml_exports))).qml,
   qsharp: async () => (await Promise.resolve().then(() => (init_qsharp(), qsharp_exports))).qsharp,
@@ -17958,6 +19168,7 @@ var languageLoaders = {
   rebol: async () => (await Promise.resolve().then(() => (init_rebol(), rebol_exports))).rebol,
   red: async () => (await Promise.resolve().then(() => (init_red(), red_exports))).red,
   rego: async () => (await Promise.resolve().then(() => (init_rego(), rego_exports))).rego,
+  renpy: async () => (await Promise.resolve().then(() => (init_renpy(), renpy_exports))).renpy,
   rescript: async () => (await Promise.resolve().then(() => (init_rescript(), rescript_exports))).rescript,
   restructuredtext: async () => (await Promise.resolve().then(() => (init_restructuredtext(), restructuredtext_exports))).restructuredtext,
   rexx: async () => (await Promise.resolve().then(() => (init_rexx(), rexx_exports))).rexx,
@@ -17971,8 +19182,10 @@ var languageLoaders = {
   scss: async () => (await Promise.resolve().then(() => (init_scss(), scss_exports))).scss,
   self: async () => (await Promise.resolve().then(() => (init_self(), self_exports))).self,
   simula: async () => (await Promise.resolve().then(() => (init_simula(), simula_exports))).simula,
+  slang: async () => (await Promise.resolve().then(() => (init_slang(), slang_exports))).slang,
   smalltalk: async () => (await Promise.resolve().then(() => (init_smalltalk(), smalltalk_exports))).smalltalk,
   smarty: async () => (await Promise.resolve().then(() => (init_smarty(), smarty_exports))).smarty,
+  smithy: async () => (await Promise.resolve().then(() => (init_smithy(), smithy_exports))).smithy,
   snakemake: async () => (await Promise.resolve().then(() => (init_snakemake(), snakemake_exports))).snakemake,
   snobol: async () => (await Promise.resolve().then(() => (init_snobol(), snobol_exports))).snobol,
   solidity: async () => (await Promise.resolve().then(() => (init_solidity(), solidity_exports))).solidity,
@@ -17987,9 +19200,11 @@ var languageLoaders = {
   starlark: async () => (await Promise.resolve().then(() => (init_starlark(), starlark_exports))).starlark,
   stata: async () => (await Promise.resolve().then(() => (init_stata(), stata_exports))).stata,
   stylus: async () => (await Promise.resolve().then(() => (init_stylus(), stylus_exports))).stylus,
+  supercollider: async () => (await Promise.resolve().then(() => (init_supercollider(), supercollider_exports))).supercollider,
   svelte: async () => (await Promise.resolve().then(() => (init_svelte(), svelte_exports))).svelte,
   svg: async () => (await Promise.resolve().then(() => (init_svg(), svg_exports))).svg,
   svn: async () => (await Promise.resolve().then(() => (init_svn(), svn_exports))).svn,
+  sway: async () => (await Promise.resolve().then(() => (init_sway(), sway_exports))).sway,
   swift: async () => (await Promise.resolve().then(() => (init_swift(), swift_exports))).swift,
   tcl: async () => (await Promise.resolve().then(() => (init_tcl(), tcl_exports))).tcl,
   tcsh: async () => (await Promise.resolve().then(() => (init_tcsh(), tcsh_exports))).tcsh,
@@ -18003,6 +19218,7 @@ var languageLoaders = {
   twee: async () => (await Promise.resolve().then(() => (init_twee(), twee_exports))).twee,
   twig: async () => (await Promise.resolve().then(() => (init_twig(), twig_exports))).twig,
   typescript: async () => (await Promise.resolve().then(() => (init_typescript(), typescript_exports))).typescript,
+  typespec: async () => (await Promise.resolve().then(() => (init_typespec(), typespec_exports))).typespec,
   typst: async () => (await Promise.resolve().then(() => (init_typst(), typst_exports))).typst,
   unison: async () => (await Promise.resolve().then(() => (init_unison(), unison_exports))).unison,
   v: async () => (await Promise.resolve().then(() => (init_v(), v_exports))).v,
@@ -18355,6 +19571,7 @@ init_actionscript();
 init_ada();
 init_agda();
 init_algol();
+init_alloy();
 init_ampl();
 init_angelscript();
 init_ante();
@@ -18386,12 +19603,14 @@ init_bosque();
 init_bqn();
 init_brainfuck();
 init_c();
+init_c3();
 init_cairo();
 init_capnproto();
 init_carbon();
 init_cel();
 init_chapel();
 init_circom();
+init_clarity();
 init_clojure();
 init_cmake();
 init_cobol();
@@ -18406,6 +19625,7 @@ init_css();
 init_cuda();
 init_cue();
 init_curry();
+init_cwl();
 init_cypher();
 init_cython();
 init_d();
@@ -18417,6 +19637,7 @@ init_dita();
 init_dockerfile();
 init_dot();
 init_earthly();
+init_edgeql();
 init_editorconfig();
 init_eiffel();
 init_ejs();
@@ -18426,10 +19647,12 @@ init_emacs_lisp();
 init_erb();
 init_erlang();
 init_factor();
+init_faust();
 init_fe();
 init_fennel();
 init_fish();
 init_flatbuffers();
+init_flix();
 init_flux();
 init_forth();
 init_fortran();
@@ -18437,6 +19660,7 @@ init_fql();
 init_freemarker();
 init_fsharp();
 init_fstar();
+init_futhark();
 init_gcode();
 init_gdscript();
 init_gettext();
@@ -18467,6 +19691,7 @@ init_ink();
 init_ink_narrative();
 init_io();
 init_isabelle();
+init_j();
 init_janet();
 init_java();
 init_javascript();
@@ -18524,6 +19749,7 @@ init_nginx();
 init_nickel();
 init_nim();
 init_nix();
+init_noir();
 init_nunjucks();
 init_nushell();
 init_oberon();
@@ -18554,10 +19780,12 @@ init_prolog();
 init_promql();
 init_properties();
 init_protobuf();
+init_prql();
 init_pug();
 init_puppet();
 init_purescript();
 init_python();
+init_q();
 init_qmake();
 init_qml();
 init_qsharp();
@@ -18569,6 +19797,7 @@ init_reasonml();
 init_rebol();
 init_red();
 init_rego();
+init_renpy();
 init_rescript();
 init_restructuredtext();
 init_rexx();
@@ -18582,8 +19811,10 @@ init_scheme();
 init_scss();
 init_self();
 init_simula();
+init_slang();
 init_smalltalk();
 init_smarty();
+init_smithy();
 init_snakemake();
 init_snobol();
 init_solidity();
@@ -18598,9 +19829,11 @@ init_standard_ml();
 init_starlark();
 init_stata();
 init_stylus();
+init_supercollider();
 init_svelte();
 init_svg();
 init_svn();
+init_sway();
 init_swift();
 init_tcl();
 init_tcsh();
@@ -18614,6 +19847,7 @@ init_tsql();
 init_twee();
 init_twig();
 init_typescript();
+init_typespec();
 init_typst();
 init_unison();
 init_v();
@@ -18651,6 +19885,7 @@ var languages = [
   ada,
   agda,
   algol,
+  alloy,
   ampl,
   angelscript,
   ante,
@@ -18682,12 +19917,14 @@ var languages = [
   bqn,
   brainfuck,
   c,
+  c3,
   cairo,
   capnproto,
   carbon,
   cel,
   chapel,
   circom,
+  clarity,
   clojure,
   cmake,
   cobol,
@@ -18702,6 +19939,7 @@ var languages = [
   cuda,
   cue,
   curry,
+  cwl,
   cypher,
   cython,
   d,
@@ -18713,6 +19951,7 @@ var languages = [
   dockerfile,
   dot,
   earthly,
+  edgeql,
   editorconfig,
   eiffel,
   ejs,
@@ -18722,10 +19961,12 @@ var languages = [
   erb,
   erlang,
   factor,
+  faust,
   fe,
   fennel,
   fish,
   flatbuffers,
+  flix,
   flux,
   forth,
   fortran,
@@ -18733,6 +19974,7 @@ var languages = [
   freemarker,
   fsharp,
   fstar,
+  futhark,
   gcode,
   gdscript,
   gettext,
@@ -18763,6 +20005,7 @@ var languages = [
   inkNarrative,
   io,
   isabelle,
+  j,
   janet,
   java,
   javascript,
@@ -18820,6 +20063,7 @@ var languages = [
   nickel,
   nim,
   nix,
+  noir,
   nunjucks,
   nushell,
   oberon,
@@ -18850,10 +20094,12 @@ var languages = [
   promql,
   properties,
   protobuf,
+  prql,
   pug,
   puppet,
   purescript,
   python,
+  q,
   qmake,
   qml,
   qsharp,
@@ -18865,6 +20111,7 @@ var languages = [
   rebol,
   red,
   rego,
+  renpy,
   rescript,
   restructuredtext,
   rexx,
@@ -18878,8 +20125,10 @@ var languages = [
   scss,
   self,
   simula,
+  slang,
   smalltalk,
   smarty,
+  smithy,
   snakemake,
   snobol,
   solidity,
@@ -18894,9 +20143,11 @@ var languages = [
   starlark,
   stata,
   stylus,
+  supercollider,
   svelte,
   svg,
   svn,
+  sway,
   swift,
   tcl,
   tcsh,
@@ -18910,6 +20161,7 @@ var languages = [
   twee,
   twig,
   typescript,
+  typespec,
   typst,
   unison,
   v,
@@ -19856,6 +21108,10 @@ var loadDetectedLanguages = async (filename) => {
   return detectedLanguages.filter((language) => Boolean(language));
 };
 var getLanguageBySlug = (slug) => languageMap.get(slug);
+var getRelationSlugs = (language) => {
+  const { supersetOf = [], dialectOf = [], compilesTo = [] } = language.relations ?? {};
+  return [...supersetOf, ...dialectOf, ...compilesTo];
+};
 var getDetectedLanguages = (filename) => detectLanguageSlugs(filename).map((slug) => getLanguageBySlug(slug)).filter((language) => Boolean(language));
 var api = {
   /**
@@ -19931,6 +21187,84 @@ var api = {
       }
     };
   },
+  /**
+   * Searches languages by name, slug, or alias with ranked results.
+   *
+   * Ranking: exact slug/alias/name match, then name or slug prefix, then name
+   * substring, then slug or alias substring. Empty queries return no results.
+   *
+   * @example
+   * api.search('type').get().map((language) => language.slug); // ["typescript", "typst", ...]
+   * api.search('golang').get().at(0)?.slug; // "go"
+   */
+  search(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    const rankLanguage = (language) => {
+      const name = language.i18n.en.name.toLowerCase();
+      const aliases = (language.aliases ?? []).map((alias) => alias.toLowerCase());
+      if (language.slug === normalizedQuery || name === normalizedQuery || aliases.includes(normalizedQuery)) {
+        return 4;
+      }
+      if (name.startsWith(normalizedQuery) || language.slug.startsWith(normalizedQuery)) {
+        return 3;
+      }
+      if (name.includes(normalizedQuery)) {
+        return 2;
+      }
+      if (language.slug.includes(normalizedQuery) || aliases.some((alias) => alias.includes(normalizedQuery))) {
+        return 1;
+      }
+      return 0;
+    };
+    const ranked = () => {
+      if (!normalizedQuery) {
+        return [];
+      }
+      return languages.map((language, index) => ({ language, index, rank: rankLanguage(language) })).filter(({ rank }) => rank > 0).sort((first, second) => second.rank - first.rank || first.index - second.index).map(({ language }) => language);
+    };
+    return createLanguageCollectionRequest(ranked, async () => {
+      const loaded = await Promise.all(ranked().map((language) => loadLanguage(language.slug)));
+      return loaded.filter((language) => Boolean(language));
+    });
+  },
+  /**
+   * Selects every language with the given lifecycle status.
+   *
+   * Languages without a `status` field count as `active`.
+   *
+   * @example
+   * api.status('legacy').langs().get();
+   * api.status('experimental').langs().locale('es').get();
+   */
+  status(value) {
+    return {
+      langs() {
+        return createFilteredLanguageCollection(
+          (language) => (language.status ?? "active") === value
+        );
+      }
+    };
+  },
+  /**
+   * Selects every language related to the given language through `relations`,
+   * in either direction.
+   *
+   * @example
+   * api.related('javascript').langs().get(); // TypeScript, CoffeeScript, Elm, ...
+   * api.related('typescript').langs().get(); // JavaScript
+   */
+  related(slug) {
+    const resolvedSlug = resolveLanguageLookup(slug);
+    return {
+      langs() {
+        const source = getLanguageBySlug(resolvedSlug);
+        const outgoing = new Set(source ? getRelationSlugs(source) : []);
+        return createFilteredLanguageCollection(
+          (language) => language.slug !== resolvedSlug && (outgoing.has(language.slug) || getRelationSlugs(language).includes(resolvedSlug))
+        );
+      }
+    };
+  },
   /**
    * Selects every language that runs on or targets the given platform or runtime.
    *
@@ -20061,5 +21395,8 @@ var api = {
     );
   }
 };
+function getStatuses() {
+  return ["active", "experimental", "legacy", "historical"];
+}
 
-export { api };
+export { api, getStatuses };