code-languages 1.20.6 → 1.22.0

package/dist/detect.cjs

@@ -85,6 +85,35 @@ var ada = {
   }
 };
 
+// src/languages/agda.ts
+var agda = {
+  slug: "agda",
+  publishedDate: "2007-01-01",
+  extensions: [".agda", ".lagda", ".lagda.md", ".lagda.rst", ".lagda.tex"],
+  author: "Ulf Norell / Chalmers University of Technology",
+  website: "https://wiki.portal.chalmers.se/agda/",
+  paradigms: ["functional", "dependently typed", "total", "proof-oriented"],
+  tooling: {
+    runtimes: ["GHC", "JavaScript"],
+    packageManagers: ["Cabal", "Stack"],
+    ecosystems: ["Haskell", "Formal methods", "Proof assistants"]
+  },
+  version: "2.8.0",
+  logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_agda.svg",
+  i18n: {
+    en: {
+      name: "Agda",
+      description: "A dependently typed functional language and proof assistant.",
+      longDescription: "Agda is a dependently typed functional programming language and interactive proof assistant. It supports inductive families, pattern matching, modules, mixfix operators, Unicode syntax, and a type system expressive enough to encode mathematical proofs as programs.\n\nIt is used in programming language research, constructive mathematics, certified algorithms, and education where precise specifications and machine-checked proofs matter as much as executable code."
+    },
+    es: {
+      name: "Agda",
+      description: "Un lenguaje funcional con tipos dependientes y asistente de pruebas.",
+      longDescription: "Agda es un lenguaje de programacion funcional con tipos dependientes y un asistente interactivo de pruebas. Soporta familias inductivas, pattern matching, modulos, operadores mixfix, sintaxis Unicode y un sistema de tipos expresivo para codificar pruebas matematicas como programas.\n\nSe usa en investigacion de lenguajes, matematica constructiva, algoritmos certificados y educacion cuando las especificaciones precisas y las pruebas verificadas por maquina importan tanto como el codigo ejecutable."
+    }
+  }
+};
+
 // src/languages/antlr.ts
 var antlr = {
   slug: "antlr",
@@ -574,6 +603,93 @@ var c = {
   }
 };
 
+// src/languages/carbon.ts
+var carbon = {
+  slug: "carbon",
+  publishedDate: "2022-07-19",
+  extensions: [".carbon"],
+  author: "Carbon Language Project",
+  website: "https://docs.carbon-lang.dev",
+  paradigms: ["imperative", "object-oriented", "generic", "statically typed"],
+  tooling: {
+    runtimes: ["LLVM"],
+    packageManagers: ["Bazel"],
+    ecosystems: ["C++", "Systems programming"]
+  },
+  version: "0.0.0 nightly",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/e/e1/Carbon_logo.png",
+  i18n: {
+    en: {
+      name: "Carbon",
+      description: "An experimental successor language for C++ interoperability and migration.",
+      longDescription: "Carbon is an experimental systems programming language designed as a possible successor to C++. It focuses on readable syntax, strong generics, modern tooling, and incremental migration paths for large C++ codebases.\n\nThe project is still pre-stable, so real-world use is centered on experiments, design evaluation, compiler development, and discussions about long-term interoperability with existing C++ ecosystems."
+    },
+    es: {
+      name: "Carbon",
+      description: "Un lenguaje experimental sucesor para interoperabilidad y migracion desde C++.",
+      longDescription: "Carbon es un lenguaje experimental de programacion de sistemas disenado como posible sucesor de C++. Se enfoca en sintaxis legible, genericos fuertes, herramientas modernas y rutas de migracion incremental para bases de codigo grandes en C++.\n\nEl proyecto aun no es estable, asi que su uso real se centra en experimentos, evaluacion de diseno, desarrollo del compilador y debates sobre interoperabilidad a largo plazo con ecosistemas C++ existentes."
+    }
+  }
+};
+
+// src/languages/chapel.ts
+var chapel = {
+  slug: "chapel",
+  publishedDate: "2009-04-01",
+  extensions: [".chpl"],
+  author: "Cray Inc. / Hewlett Packard Enterprise",
+  website: "https://chapel-lang.org",
+  paradigms: ["parallel", "imperative", "object-oriented", "generic"],
+  tooling: {
+    runtimes: ["Chapel runtime"],
+    packageManagers: ["Mason"],
+    ecosystems: ["High-performance computing", "Parallel computing"]
+  },
+  version: "2.6.0",
+  logo: "https://chapel-lang.org/images/chapel-logo.png",
+  i18n: {
+    en: {
+      name: "Chapel",
+      description: "A productive parallel programming language for scalable systems.",
+      longDescription: "Chapel is a parallel programming language created to make high-performance and distributed computing more approachable. It provides domains, arrays, task parallelism, data parallelism, locality control, and abstractions for writing scalable programs without dropping into low-level message passing everywhere.\n\nIt is used for research, numerical computing, data analytics, simulations, and high-performance applications that need to express parallel algorithms clearly across laptops, clusters, and supercomputers."
+    },
+    es: {
+      name: "Chapel",
+      description: "Un lenguaje de programacion paralela productivo para sistemas escalables.",
+      longDescription: "Chapel es un lenguaje de programacion paralela creado para hacer mas accesible la computacion de alto rendimiento y distribuida. Ofrece dominios, arreglos, paralelismo de tareas, paralelismo de datos, control de localidad y abstracciones para escribir programas escalables sin depender siempre de paso de mensajes de bajo nivel.\n\nSe usa en investigacion, computacion numerica, analitica de datos, simulaciones y aplicaciones de alto rendimiento que necesitan expresar algoritmos paralelos con claridad en laptops, clusters y supercomputadoras."
+    }
+  }
+};
+
+// src/languages/circom.ts
+var circom = {
+  slug: "circom",
+  publishedDate: "2018-01-01",
+  extensions: [".circom"],
+  author: "iden3",
+  website: "https://docs.circom.io",
+  paradigms: ["declarative", "constraint-based", "domain-specific"],
+  tooling: {
+    runtimes: ["circom compiler", "WebAssembly", "C++"],
+    packageManagers: ["npm", "Cargo"],
+    ecosystems: ["Zero-knowledge proofs", "Ethereum", "zkSNARKs"]
+  },
+  version: "2.2.3",
+  logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_circom.svg",
+  i18n: {
+    en: {
+      name: "Circom",
+      description: "A DSL for writing arithmetic circuits used in zero-knowledge proofs.",
+      longDescription: "Circom is a domain-specific language for defining arithmetic circuits used by zkSNARK proving systems. Its compiler can generate constraint systems together with witness-generation code for C++ or WebAssembly.\n\nIt is common in privacy-preserving protocols, identity systems, blockchain applications, and cryptographic projects that need reusable circuits for zero-knowledge proofs."
+    },
+    es: {
+      name: "Circom",
+      description: "Un DSL para escribir circuitos aritmeticos usados en pruebas de conocimiento cero.",
+      longDescription: "Circom es un lenguaje especifico de dominio para definir circuitos aritmeticos usados por sistemas de prueba zkSNARK. Su compilador puede generar sistemas de restricciones junto con codigo de generacion de testigos para C++ o WebAssembly.\n\nEs comun en protocolos de privacidad, sistemas de identidad, aplicaciones blockchain y proyectos criptograficos que necesitan circuitos reutilizables para pruebas de conocimiento cero."
+    }
+  }
+};
+
 // src/languages/clojure.ts
 var clojure = {
   slug: "clojure",
@@ -717,6 +833,35 @@ var coldfusion = {
   }
 };
 
+// src/languages/coq.ts
+var coq = {
+  slug: "coq",
+  publishedDate: "1989-01-01",
+  extensions: [".v"],
+  author: "INRIA / Rocq Prover Development Team",
+  website: "https://rocq-prover.org",
+  paradigms: ["functional", "dependently typed", "proof-oriented", "tactic-based"],
+  tooling: {
+    runtimes: ["Rocq Prover", "OCaml"],
+    packageManagers: ["opam", "Rocq Platform"],
+    ecosystems: ["Formal methods", "Proof assistants", "OCaml"]
+  },
+  version: "9.2.0",
+  logo: "https://avatars.githubusercontent.com/u/621198?v=4",
+  i18n: {
+    en: {
+      name: "Coq / Rocq",
+      description: "A proof assistant and dependently typed language for certified mathematics and software.",
+      longDescription: "Coq, now released under the Rocq Prover name, is an interactive theorem prover and dependently typed language. It lets users write definitions, executable programs, theorems, and machine-checked proofs in one environment.\n\nIt is widely used in formal verification, programming language metatheory, certified compilers, mathematics, cryptography, and projects where correctness arguments need to be checked with high confidence."
+    },
+    es: {
+      name: "Coq / Rocq",
+      description: "Un asistente de pruebas y lenguaje con tipos dependientes para software certificado.",
+      longDescription: "Coq, publicado ahora bajo el nombre Rocq Prover, es un demostrador interactivo de teoremas y un lenguaje con tipos dependientes. Permite escribir definiciones, programas ejecutables, teoremas y pruebas verificadas por maquina en un mismo entorno.\n\nSe usa ampliamente en verificacion formal, metateoria de lenguajes, compiladores certificados, matematica, criptografia y proyectos donde los argumentos de correccion deben comprobarse con alta confianza."
+    }
+  }
+};
+
 // src/languages/cpp.ts
 var cpp = {
   slug: "cpp",
@@ -973,6 +1118,64 @@ var dart = {
   }
 };
 
+// src/languages/dhall.ts
+var dhall = {
+  slug: "dhall",
+  publishedDate: "2016-12-22",
+  extensions: [".dhall"],
+  author: "Gabriel Gonzalez",
+  website: "https://dhall-lang.org",
+  paradigms: ["functional", "declarative", "statically typed", "configuration"],
+  tooling: {
+    runtimes: ["dhall"],
+    packageManagers: ["Cabal", "Stack", "Nix"],
+    ecosystems: ["Configuration", "Haskell", "DevOps"]
+  },
+  version: "23.1.0",
+  logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_dhall.svg",
+  i18n: {
+    en: {
+      name: "Dhall",
+      description: "A programmable, typed configuration language that normalizes safely.",
+      longDescription: "Dhall is a programmable configuration language with a strong static type system, imports, functions, records, and guaranteed normalization. It is designed to replace repetitive JSON, YAML, and similar configuration formats with reusable typed expressions.\n\nIt is used for infrastructure configuration, application settings, generated YAML or JSON, and systems that need shared configuration without arbitrary code execution."
+    },
+    es: {
+      name: "Dhall",
+      description: "Un lenguaje de configuracion programable, tipado y de normalizacion segura.",
+      longDescription: "Dhall es un lenguaje de configuracion programable con un sistema de tipos estatico fuerte, imports, funciones, registros y normalizacion garantizada. Esta disenado para reemplazar JSON, YAML y formatos similares repetitivos con expresiones tipadas reutilizables.\n\nSe usa en configuracion de infraestructura, ajustes de aplicaciones, generacion de YAML o JSON y sistemas que necesitan configuracion compartida sin ejecucion arbitraria de codigo."
+    }
+  }
+};
+
+// src/languages/dita.ts
+var dita = {
+  slug: "dita",
+  publishedDate: "2005-05-03",
+  extensions: [".dita", ".ditamap", ".ditaval"],
+  author: "OASIS",
+  website: "https://www.oasis-open.org/standard/dita/",
+  paradigms: ["markup", "structured authoring", "XML-based", "documentation"],
+  tooling: {
+    runtimes: ["DITA Open Toolkit"],
+    packageManagers: ["npm", "Maven"],
+    ecosystems: ["Technical writing", "XML", "Publishing"]
+  },
+  version: "1.3",
+  logo: "https://avatars.githubusercontent.com/u/20116735?v=4",
+  i18n: {
+    en: {
+      name: "DITA",
+      description: "An XML-based architecture for structured technical documentation.",
+      longDescription: "DITA is the Darwin Information Typing Architecture, an XML-based standard for topic-oriented authoring. It defines topic types, maps, specialization, reuse mechanisms, and publishing-oriented metadata for large documentation sets.\n\nIt is used in technical writing, product documentation, regulated content, localization workflows, and publishing pipelines that need structured reusable topics rather than page-by-page documents."
+    },
+    es: {
+      name: "DITA",
+      description: "Una arquitectura basada en XML para documentacion tecnica estructurada.",
+      longDescription: "DITA es Darwin Information Typing Architecture, un estandar basado en XML para autoria orientada a topicos. Define tipos de topico, mapas, especializacion, mecanismos de reutilizacion y metadatos de publicacion para grandes conjuntos de documentacion.\n\nSe usa en redaccion tecnica, documentacion de productos, contenido regulado, flujos de localizacion y pipelines de publicacion que necesitan topicos estructurados y reutilizables en vez de documentos pagina por pagina."
+    }
+  }
+};
+
 // src/languages/dockerfile.ts
 var dockerfile = {
   slug: "dockerfile",
@@ -1001,6 +1204,35 @@ var dockerfile = {
   }
 };
 
+// src/languages/earthly.ts
+var earthly = {
+  slug: "earthly",
+  publishedDate: "2020-04-15",
+  extensions: ["Earthfile"],
+  author: "Earthly Technologies",
+  website: "https://earthly.dev",
+  paradigms: ["declarative", "build automation", "container-based"],
+  tooling: {
+    runtimes: ["Earthly", "BuildKit", "Docker"],
+    packageManagers: ["Docker"],
+    ecosystems: ["CI/CD", "Containers", "DevOps"]
+  },
+  version: "0.8.16",
+  logo: "https://avatars.githubusercontent.com/u/63060917?v=4",
+  i18n: {
+    en: {
+      name: "Earthly",
+      description: "A container-oriented build language for repeatable CI/CD pipelines.",
+      longDescription: "Earthly is a build automation language and tool centered on Earthfiles. Its syntax combines ideas from Dockerfiles and Makefiles to define repeatable builds, targets, artifacts, images, and CI-friendly workflows.\n\nIt is used by teams that want local and CI builds to behave consistently, especially in container-heavy projects where caching, reproducibility, and readable build steps matter."
+    },
+    es: {
+      name: "Earthly",
+      description: "Un lenguaje de builds orientado a contenedores para pipelines CI/CD repetibles.",
+      longDescription: "Earthly es un lenguaje y herramienta de automatizacion de builds centrado en Earthfiles. Su sintaxis combina ideas de Dockerfiles y Makefiles para definir builds repetibles, targets, artefactos, imagenes y flujos adecuados para CI.\n\nLo usan equipos que quieren que los builds locales y de CI se comporten de forma consistente, especialmente en proyectos con muchos contenedores donde importan cache, reproducibilidad y pasos de build legibles."
+    }
+  }
+};
+
 // src/languages/elixir.ts
 var elixir = {
   slug: "elixir",
@@ -1463,6 +1695,64 @@ var groovy = {
   }
 };
 
+// src/languages/hack.ts
+var hack = {
+  slug: "hack",
+  publishedDate: "2014-03-20",
+  extensions: [".hack", ".hh", ".hhi"],
+  author: "Meta",
+  website: "https://docs.hhvm.com/hack/",
+  paradigms: ["object-oriented", "functional", "gradually typed", "imperative"],
+  tooling: {
+    runtimes: ["HHVM"],
+    packageManagers: ["Composer"],
+    ecosystems: ["HHVM", "Web", "PHP"]
+  },
+  version: "HHVM 4.x",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/a/a7/Hack_%28programming_language%29_logo.svg",
+  i18n: {
+    en: {
+      name: "Hack",
+      description: "A gradually typed language for HHVM with PHP heritage.",
+      longDescription: "Hack is a programming language for HHVM that evolved from PHP and adds static typing, generics, async features, shapes, collections, and tooling built around the Hack typechecker. It is designed for large web codebases that need gradual typing and fast feedback.\n\nIt is used mainly in HHVM deployments and large server-side applications where PHP-like ergonomics are paired with stronger static analysis and modern language constructs."
+    },
+    es: {
+      name: "Hack",
+      description: "Un lenguaje con tipado gradual para HHVM con herencia de PHP.",
+      longDescription: "Hack es un lenguaje de programacion para HHVM que evoluciono desde PHP y agrega tipado estatico, genericos, funciones async, shapes, colecciones y herramientas basadas en el typechecker de Hack. Esta disenado para grandes bases de codigo web que necesitan tipado gradual y feedback rapido.\n\nSe usa principalmente en despliegues HHVM y aplicaciones grandes del lado servidor donde la ergonomia similar a PHP se combina con analisis estatico mas fuerte y construcciones modernas del lenguaje."
+    }
+  }
+};
+
+// src/languages/haml.ts
+var haml = {
+  slug: "haml",
+  publishedDate: "2006-10-01",
+  extensions: [".haml"],
+  author: "Hampton Catlin",
+  website: "https://haml.info",
+  paradigms: ["template", "markup", "declarative"],
+  tooling: {
+    runtimes: ["Ruby"],
+    packageManagers: ["RubyGems", "Bundler"],
+    ecosystems: ["Ruby", "Ruby on Rails", "Web"]
+  },
+  version: "7.2.0",
+  logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_haml.svg",
+  i18n: {
+    en: {
+      name: "Haml",
+      description: "A whitespace-sensitive template language for writing HTML tersely.",
+      longDescription: "Haml is a markup and template language for generating HTML with indentation-based structure. It removes closing tags, reduces boilerplate, and integrates with Ruby frameworks such as Ruby on Rails.\n\nIt is used in web applications and static rendering pipelines that prefer concise templates, readable nesting, and Ruby-powered interpolation over explicit HTML syntax."
+    },
+    es: {
+      name: "Haml",
+      description: "Un lenguaje de templates sensible a espacios para escribir HTML de forma concisa.",
+      longDescription: "Haml es un lenguaje de marcado y templates para generar HTML con estructura basada en indentacion. Elimina etiquetas de cierre, reduce repeticion e integra con frameworks Ruby como Ruby on Rails.\n\nSe usa en aplicaciones web y pipelines de renderizado estatico que prefieren templates concisos, anidacion legible e interpolacion con Ruby en vez de sintaxis HTML explicita."
+    }
+  }
+};
+
 // src/languages/handlebars.ts
 var handlebars = {
   slug: "handlebars",
@@ -1632,6 +1922,35 @@ var html = {
   }
 };
 
+// src/languages/idris.ts
+var idris = {
+  slug: "idris",
+  publishedDate: "2009-01-01",
+  extensions: [".idr", ".lidr", ".ipkg"],
+  author: "Edwin Brady",
+  website: "https://www.idris-lang.org",
+  paradigms: ["functional", "dependently typed", "total", "statically typed"],
+  tooling: {
+    runtimes: ["Chez Scheme", "Racket", "JavaScript", "Node.js"],
+    packageManagers: ["pack", "idris2"],
+    ecosystems: ["Formal methods", "Functional programming"]
+  },
+  version: "0.8.0",
+  logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_idris.svg",
+  i18n: {
+    en: {
+      name: "Idris",
+      description: "A dependently typed functional language focused on practical programs.",
+      longDescription: "Idris is a dependently typed functional programming language that brings theorem-proving ideas into general-purpose software development. Idris 2 adds a quantitative type system, totality checking, elaborator reflection, and multiple code generation backends.\n\nIt is used for type-driven development, language research, certified programming, education, and experiments where rich types help describe program behavior precisely."
+    },
+    es: {
+      name: "Idris",
+      description: "Un lenguaje funcional con tipos dependientes enfocado en programas practicos.",
+      longDescription: "Idris es un lenguaje de programacion funcional con tipos dependientes que lleva ideas de demostracion de teoremas al desarrollo general. Idris 2 agrega un sistema de tipos cuantitativo, chequeo de totalidad, reflexion de elaborador y multiples backends de generacion de codigo.\n\nSe usa en desarrollo guiado por tipos, investigacion de lenguajes, programacion certificada, educacion y experimentos donde tipos ricos ayudan a describir con precision el comportamiento de los programas."
+    }
+  }
+};
+
 // src/languages/ini.ts
 var ini = {
   slug: "ini",
@@ -1659,6 +1978,35 @@ var ini = {
   }
 };
 
+// src/languages/janet.ts
+var janet = {
+  slug: "janet",
+  publishedDate: "2017-09-01",
+  extensions: [".janet", ".jdn"],
+  author: "Calvin Rose",
+  website: "https://janet-lang.org",
+  paradigms: ["functional", "imperative", "lisp", "embedded"],
+  tooling: {
+    runtimes: ["Janet VM"],
+    packageManagers: ["jpm"],
+    ecosystems: ["Scripting", "Embedded systems", "Command-line tools"]
+  },
+  version: "1.39.1",
+  logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_janet.svg",
+  i18n: {
+    en: {
+      name: "Janet",
+      description: "A small Lisp-like language and embeddable runtime for scripting.",
+      longDescription: "Janet is a small Lisp-like programming language with a compact C implementation, fibers, tables, pattern matching, macros, and an embeddable runtime. It is designed for scripting, tools, and applications that need a lightweight extension language.\n\nIt is used for command-line programs, configuration, automation, embedding in native applications, and experiments that benefit from Lisp-style metaprogramming without a large runtime."
+    },
+    es: {
+      name: "Janet",
+      description: "Un lenguaje pequeno tipo Lisp y runtime embebible para scripting.",
+      longDescription: "Janet es un lenguaje de programacion pequeno tipo Lisp con una implementacion compacta en C, fibras, tablas, pattern matching, macros y un runtime embebible. Esta disenado para scripting, herramientas y aplicaciones que necesitan un lenguaje de extension liviano.\n\nSe usa en programas de linea de comandos, configuracion, automatizacion, embedding en aplicaciones nativas y experimentos que aprovechan metaprogramacion tipo Lisp sin un runtime grande."
+    }
+  }
+};
+
 // src/languages/java.ts
 var java = {
   slug: "java",
@@ -1886,6 +2234,35 @@ var kotlin = {
   }
 };
 
+// src/languages/lean.ts
+var lean = {
+  slug: "lean",
+  publishedDate: "2013-06-16",
+  extensions: [".lean"],
+  author: "Leonardo de Moura / Microsoft Research",
+  website: "https://lean-lang.org",
+  paradigms: ["functional", "dependently typed", "proof-oriented", "metaprogramming"],
+  tooling: {
+    runtimes: ["Lean"],
+    packageManagers: ["Lake", "elan"],
+    ecosystems: ["Formal methods", "Mathematics", "Proof assistants"]
+  },
+  version: "4.29.1",
+  logo: "https://cdn.simpleicons.org/leanpub/262425",
+  i18n: {
+    en: {
+      name: "Lean",
+      description: "A theorem prover and functional language for formalized mathematics and software.",
+      longDescription: "Lean is a theorem prover and dependently typed functional programming language. Lean 4 includes an efficient compiler, extensible syntax, metaprogramming facilities, tactics, and tooling for large formalization projects.\n\nIt is used in formalized mathematics, program verification, theorem proving research, educational games, and software projects where proofs and executable definitions can evolve together."
+    },
+    es: {
+      name: "Lean",
+      description: "Un demostrador de teoremas y lenguaje funcional para matematica y software formalizados.",
+      longDescription: "Lean es un demostrador de teoremas y lenguaje funcional con tipos dependientes. Lean 4 incluye un compilador eficiente, sintaxis extensible, metaprogramacion, tacticas y herramientas para grandes proyectos de formalizacion.\n\nSe usa en matematica formalizada, verificacion de programas, investigacion en demostracion de teoremas, juegos educativos y proyectos donde pruebas y definiciones ejecutables pueden evolucionar juntas."
+    }
+  }
+};
+
 // src/languages/less.ts
 var less = {
   slug: "less",
@@ -1973,6 +2350,35 @@ var lisp = {
   }
 };
 
+// src/languages/llvm-ir.ts
+var llvmIr = {
+  slug: "llvm-ir",
+  publishedDate: "2003-10-01",
+  extensions: [".ll", ".bc"],
+  author: "LLVM Project",
+  website: "https://llvm.org/docs/LangRef.html",
+  paradigms: ["intermediate representation", "static single assignment", "compiler"],
+  tooling: {
+    runtimes: ["LLVM"],
+    packageManagers: ["LLVM releases"],
+    ecosystems: ["Compilers", "Systems programming", "Toolchains"]
+  },
+  version: "22.1.5",
+  logo: "https://cdn.simpleicons.org/llvm/262D3A",
+  i18n: {
+    en: {
+      name: "LLVM IR",
+      description: "The typed intermediate representation used by the LLVM compiler infrastructure.",
+      longDescription: "LLVM IR is the typed, low-level intermediate representation used by the LLVM compiler infrastructure. It has a textual form, bitcode form, SSA-based values, explicit control flow, and a language reference that defines instructions, types, attributes, and metadata.\n\nIt is used by compilers, optimizers, static analyzers, JIT systems, language implementations, and tools that need a portable representation between source languages and machine code."
+    },
+    es: {
+      name: "LLVM IR",
+      description: "La representacion intermedia tipada usada por la infraestructura de compiladores LLVM.",
+      longDescription: "LLVM IR es la representacion intermedia tipada y de bajo nivel usada por la infraestructura de compiladores LLVM. Tiene forma textual, forma bitcode, valores basados en SSA, flujo de control explicito y una referencia que define instrucciones, tipos, atributos y metadatos.\n\nSe usa en compiladores, optimizadores, analizadores estaticos, sistemas JIT, implementaciones de lenguajes y herramientas que necesitan una representacion portable entre lenguajes fuente y codigo maquina."
+    }
+  }
+};
+
 // src/languages/lua.ts
 var lua = {
   slug: "lua",
@@ -2002,6 +2408,35 @@ var lua = {
   }
 };
 
+// src/languages/luau.ts
+var luau = {
+  slug: "luau",
+  publishedDate: "2021-11-03",
+  extensions: [".luau"],
+  author: "Roblox",
+  website: "https://luau.org",
+  paradigms: ["imperative", "scripting", "gradually typed", "embeddable"],
+  tooling: {
+    runtimes: ["Luau VM", "Roblox"],
+    packageManagers: ["Wally", "Pesde"],
+    ecosystems: ["Roblox", "Games", "Embedded scripting"]
+  },
+  version: "0.719",
+  logo: "https://cdn.simpleicons.org/roblox/000000",
+  i18n: {
+    en: {
+      name: "Luau",
+      description: "A fast Lua-derived scripting language with gradual typing.",
+      longDescription: "Luau is a scripting language derived from Lua 5.1 and developed by Roblox. It adds gradual typing, performance-focused compiler and VM work, linting, type inference, and features aimed at large game codebases.\n\nIt is used in Roblox experiences, game tooling, embedded scripting, and projects that want Lua-like ergonomics with stronger static analysis and modern runtime performance."
+    },
+    es: {
+      name: "Luau",
+      description: "Un lenguaje de scripting derivado de Lua, rapido y con tipado gradual.",
+      longDescription: "Luau es un lenguaje de scripting derivado de Lua 5.1 y desarrollado por Roblox. Agrega tipado gradual, trabajo de compilador y VM orientado al rendimiento, linting, inferencia de tipos y caracteristicas para grandes bases de codigo de juegos.\n\nSe usa en experiencias de Roblox, herramientas de juegos, scripting embebido y proyectos que quieren ergonomia similar a Lua con analisis estatico mas fuerte y rendimiento moderno."
+    }
+  }
+};
+
 // src/languages/makefile.ts
 var makefile = {
   slug: "makefile",
@@ -2030,6 +2465,35 @@ var makefile = {
   }
 };
 
+// src/languages/mako.ts
+var mako = {
+  slug: "mako",
+  publishedDate: "2006-07-17",
+  extensions: [".mako", ".mao"],
+  author: "Michael Bayer / Mako contributors",
+  website: "https://www.makotemplates.org",
+  paradigms: ["templating", "declarative", "scripting"],
+  tooling: {
+    runtimes: ["Python"],
+    packageManagers: ["pip", "uv", "Poetry"],
+    ecosystems: ["Python", "Web", "Documentation"]
+  },
+  version: "1.3.10",
+  logo: "https://cdn.simpleicons.org/python/3776AB",
+  i18n: {
+    en: {
+      name: "Mako",
+      description: "A Python template language for generating text, HTML, and source artifacts.",
+      longDescription: "Mako is a Python template language that mixes text with expressions, control blocks, inheritance, includes, and reusable definitions. Templates compile to Python code, which keeps it close to the host language.\n\nIt is used for web views, documentation, code generation, configuration rendering, and projects that need expressive Python-backed templates."
+    },
+    es: {
+      name: "Mako",
+      description: "Un lenguaje de plantillas de Python para generar texto, HTML y artefactos fuente.",
+      longDescription: "Mako es un lenguaje de plantillas de Python que mezcla texto con expresiones, bloques de control, herencia, includes y definiciones reutilizables. Las plantillas compilan a codigo Python y quedan cerca del lenguaje anfitrion.\n\nSe usa en vistas web, documentacion, generacion de codigo, renderizado de configuracion y proyectos que necesitan plantillas expresivas respaldadas por Python."
+    }
+  }
+};
+
 // src/languages/markdown.ts
 var markdown = {
   slug: "markdown",
@@ -2054,6 +2518,34 @@ var markdown = {
   }
 };
 
+// src/languages/mathematica.ts
+var mathematica = {
+  slug: "mathematica",
+  publishedDate: "1988-06-23",
+  extensions: [".wl", ".wls", ".nb"],
+  author: "Stephen Wolfram / Wolfram Research",
+  website: "https://www.wolfram.com/language/",
+  paradigms: ["symbolic", "functional", "rule-based", "notebook"],
+  tooling: {
+    runtimes: ["Wolfram Engine", "Wolfram Cloud", "Mathematica"],
+    ecosystems: ["Scientific Computing", "Symbolic Computing", "Notebooks"]
+  },
+  version: "14.3",
+  logo: "https://cdn.simpleicons.org/wolfram/DD1100",
+  i18n: {
+    en: {
+      name: "Wolfram Language",
+      description: "A symbolic computation language used by Mathematica and Wolfram tools.",
+      longDescription: "The Wolfram Language combines symbolic expressions, functional programming, pattern rules, notebooks, visualization, and a large knowledge-oriented standard library. Mathematica is its best-known interactive environment.\n\nIt is used for mathematics, modeling, data science, research notebooks, education, automation, and computational reports that benefit from symbolic and numeric workflows."
+    },
+    es: {
+      name: "Wolfram Language",
+      description: "Un lenguaje de computacion simbolica usado por Mathematica y herramientas Wolfram.",
+      longDescription: "Wolfram Language combina expresiones simbolicas, programacion funcional, reglas por patrones, notebooks, visualizacion y una biblioteca estandar orientada al conocimiento. Mathematica es su entorno interactivo mas conocido.\n\nSe usa en matematicas, modelado, ciencia de datos, notebooks de investigacion, educacion, automatizacion y reportes computacionales con flujos simbolicos y numericos."
+    }
+  }
+};
+
 // src/languages/matlab.ts
 var matlab = {
   slug: "matlab",
@@ -2198,6 +2690,64 @@ var metal = {
   }
 };
 
+// src/languages/mojo.ts
+var mojo = {
+  slug: "mojo",
+  publishedDate: "2023-05-02",
+  extensions: [".mojo"],
+  author: "Modular",
+  website: "https://www.modular.com/mojo",
+  paradigms: ["imperative", "systems", "statically typed", "data-oriented"],
+  tooling: {
+    runtimes: ["Mojo toolchain", "MAX"],
+    packageManagers: ["pixi", "pip"],
+    ecosystems: ["AI", "Accelerators", "Python"]
+  },
+  version: "0.26.1",
+  logo: "https://avatars.githubusercontent.com/u/107116314?v=4",
+  i18n: {
+    en: {
+      name: "Mojo",
+      description: "A systems-oriented language for AI and accelerator-aware programming.",
+      longDescription: "Mojo is a language from Modular that combines Python-friendly syntax with ownership, value semantics, low-level control, and compiler features aimed at performance-sensitive code. Its toolchain targets CPUs and accelerator workflows.\n\nIt is used in experiments around AI kernels, numeric code, systems programming, Python-adjacent libraries, and workloads that need explicit performance control."
+    },
+    es: {
+      name: "Mojo",
+      description: "Un lenguaje orientado a sistemas para IA y programacion con aceleradores.",
+      longDescription: "Mojo es un lenguaje de Modular que combina una sintaxis cercana a Python con ownership, semantica de valores, control de bajo nivel y funciones de compilador pensadas para codigo sensible al rendimiento. Su toolchain apunta a CPUs y flujos con aceleradores.\n\nSe usa en experimentos con kernels de IA, codigo numerico, programacion de sistemas, bibliotecas cercanas a Python y cargas que necesitan control explicito del rendimiento."
+    }
+  }
+};
+
+// src/languages/moonbit.ts
+var moonbit = {
+  slug: "moonbit",
+  publishedDate: "2023-08-18",
+  extensions: [".mbt"],
+  author: "MoonBit Team",
+  website: "https://www.moonbitlang.com",
+  paradigms: ["functional", "statically typed", "multi-paradigm", "wasm"],
+  tooling: {
+    runtimes: ["MoonBit toolchain", "WebAssembly", "JavaScript"],
+    packageManagers: ["moon"],
+    ecosystems: ["WebAssembly", "Web", "Embedded"]
+  },
+  version: "0.9.2",
+  logo: "https://avatars.githubusercontent.com/u/124476259?v=4",
+  i18n: {
+    en: {
+      name: "MoonBit",
+      description: "A statically typed language and toolchain designed for WebAssembly output.",
+      longDescription: "MoonBit is a language and toolchain built around fast feedback, algebraic data types, pattern matching, and multiple backends including WebAssembly. Its package and test tools are designed as part of the language workflow.\n\nIt is used for WebAssembly libraries, command-line experiments, web runtimes, teaching, and projects that want compact typed code with integrated tooling."
+    },
+    es: {
+      name: "MoonBit",
+      description: "Un lenguaje tipado y toolchain disenado para generar WebAssembly.",
+      longDescription: "MoonBit es un lenguaje y toolchain construido alrededor de feedback rapido, tipos algebraicos, pattern matching y varios backends, incluido WebAssembly. Sus herramientas de paquetes y pruebas forman parte del flujo del lenguaje.\n\nSe usa en bibliotecas WebAssembly, experimentos de linea de comandos, runtimes web, ensenanza y proyectos que buscan codigo tipado compacto con tooling integrado."
+    }
+  }
+};
+
 // src/languages/nginx.ts
 var nginx = {
   slug: "nginx",
@@ -2342,6 +2892,63 @@ var ocaml = {
   }
 };
 
+// src/languages/odin.ts
+var odin = {
+  slug: "odin",
+  publishedDate: "2016-11-05",
+  extensions: [".odin"],
+  author: "Ginger Bill",
+  website: "https://odin-lang.org",
+  paradigms: ["imperative", "procedural", "systems", "data-oriented"],
+  tooling: {
+    runtimes: ["Odin compiler"],
+    packageManagers: ["odin"],
+    ecosystems: ["Systems", "Game Development", "Native"]
+  },
+  version: "dev-2026-02",
+  logo: "https://avatars.githubusercontent.com/u/12533910?v=4",
+  i18n: {
+    en: {
+      name: "Odin",
+      description: "A data-oriented systems language for native software and game tooling.",
+      longDescription: "Odin is a procedural systems programming language with explicit memory control, packages, foreign interfaces, custom allocators, and language features oriented toward data layout. It favors straightforward native code over large runtime machinery.\n\nIt is used for engines, tools, graphics programs, native utilities, and performance-sensitive applications where predictable control over data matters."
+    },
+    es: {
+      name: "Odin",
+      description: "Un lenguaje de sistemas orientado a datos para software nativo y juegos.",
+      longDescription: "Odin es un lenguaje procedural de programacion de sistemas con control explicito de memoria, paquetes, interfaces externas, allocators personalizados y funciones orientadas al layout de datos. Favorece codigo nativo directo sobre runtimes grandes.\n\nSe usa en motores, herramientas, programas graficos, utilidades nativas y aplicaciones sensibles al rendimiento donde importa el control predecible de los datos."
+    }
+  }
+};
+
+// src/languages/opencl.ts
+var opencl = {
+  slug: "opencl",
+  publishedDate: "2008-12-08",
+  extensions: [".cl", ".clh"],
+  author: "Khronos Group",
+  website: "https://www.khronos.org/opencl/",
+  paradigms: ["parallel", "kernel", "data-parallel", "c-family"],
+  tooling: {
+    runtimes: ["OpenCL Runtime"],
+    ecosystems: ["GPU Compute", "Heterogeneous Computing", "Khronos"]
+  },
+  version: "OpenCL C 3.0",
+  logo: "https://cdn.simpleicons.org/khronosgroup/CC3333",
+  i18n: {
+    en: {
+      name: "OpenCL C",
+      description: "The C-based kernel language for OpenCL heterogeneous compute programs.",
+      longDescription: "OpenCL C is the kernel programming language used by OpenCL to describe parallel work over devices such as CPUs, GPUs, and accelerators. It extends a C-family model with address spaces, vector types, work-items, and synchronization primitives.\n\nIt is used for compute kernels, image processing, simulations, numeric workloads, and portable heterogeneous programs that target OpenCL runtimes."
+    },
+    es: {
+      name: "OpenCL C",
+      description: "El lenguaje de kernels basado en C para programas de computo OpenCL.",
+      longDescription: "OpenCL C es el lenguaje de kernels que usa OpenCL para describir trabajo paralelo sobre dispositivos como CPUs, GPUs y aceleradores. Extiende un modelo de la familia C con espacios de direcciones, tipos vectoriales, work-items y primitivas de sincronizacion.\n\nSe usa en kernels de computo, procesamiento de imagenes, simulaciones, cargas numericas y programas heterogeneos portables dirigidos a runtimes OpenCL."
+    }
+  }
+};
+
 // src/languages/pascal.ts
 var pascal = {
   slug: "pascal",
@@ -2429,6 +3036,34 @@ var php = {
   }
 };
 
+// src/languages/pine-script.ts
+var pineScript = {
+  slug: "pine-script",
+  publishedDate: "2013-12-01",
+  extensions: [".pine"],
+  author: "TradingView",
+  website: "https://www.tradingview.com/pine-script-docs/",
+  paradigms: ["domain-specific", "time-series", "declarative", "scripting"],
+  tooling: {
+    runtimes: ["TradingView"],
+    ecosystems: ["Charts", "Trading", "Technical Analysis"]
+  },
+  version: "v6",
+  logo: "https://cdn.simpleicons.org/tradingview/131722",
+  i18n: {
+    en: {
+      name: "Pine Script",
+      description: "TradingView's language for indicators, strategies, and chart studies.",
+      longDescription: "Pine Script is a domain-specific language for expressing calculations over chart bars, series values, indicators, alerts, and trading strategies in TradingView. Its execution model is centered on time-series data.\n\nIt is used for custom technical indicators, backtested strategies, chart overlays, alerts, and market analysis shared through TradingView."
+    },
+    es: {
+      name: "Pine Script",
+      description: "El lenguaje de TradingView para indicadores, estrategias y estudios de graficos.",
+      longDescription: "Pine Script es un lenguaje de dominio especifico para expresar calculos sobre barras, series, indicadores, alertas y estrategias de trading en TradingView. Su modelo de ejecucion gira alrededor de datos temporales.\n\nSe usa en indicadores tecnicos personalizados, estrategias con backtesting, overlays de graficos, alertas y analisis de mercado compartido en TradingView."
+    }
+  }
+};
+
 // src/languages/plantuml.ts
 var plantuml = {
   slug: "plantuml",
@@ -2458,6 +3093,63 @@ var plantuml = {
   }
 };
 
+// src/languages/plsql.ts
+var plsql = {
+  slug: "plsql",
+  publishedDate: "1992-01-01",
+  extensions: [".pls", ".pks", ".pkb", ".plsql"],
+  author: "Oracle",
+  website: "https://www.oracle.com/database/technologies/appdev/plsql.html",
+  paradigms: ["procedural", "database", "declarative", "imperative"],
+  tooling: {
+    runtimes: ["Oracle Database"],
+    ecosystems: ["Oracle", "SQL", "Enterprise Data"]
+  },
+  version: "Oracle Database 26ai",
+  logo: "https://github.com/oracle.png",
+  i18n: {
+    en: {
+      name: "Oracle PL/SQL",
+      description: "Oracle's procedural extension to SQL for database programs and packages.",
+      longDescription: "PL/SQL adds blocks, variables, exceptions, procedures, functions, packages, cursors, and triggers to Oracle SQL. It keeps database logic close to data and transactional behavior inside Oracle Database.\n\nIt is used for stored procedures, migration scripts, business rules, batch jobs, packages, and enterprise database applications built on Oracle."
+    },
+    es: {
+      name: "Oracle PL/SQL",
+      description: "La extension procedural de SQL de Oracle para programas y paquetes de base de datos.",
+      longDescription: "PL/SQL agrega bloques, variables, excepciones, procedimientos, funciones, paquetes, cursores y triggers a Oracle SQL. Mantiene logica de base de datos cerca de los datos y del comportamiento transaccional en Oracle Database.\n\nSe usa en stored procedures, scripts de migracion, reglas de negocio, trabajos batch, paquetes y aplicaciones empresariales construidas sobre Oracle."
+    }
+  }
+};
+
+// src/languages/pony.ts
+var pony = {
+  slug: "pony",
+  publishedDate: "2015-04-29",
+  extensions: [".pony"],
+  author: "Sylvan Clebsch / Pony contributors",
+  website: "https://www.ponylang.io",
+  paradigms: ["actor-model", "object-oriented", "capability-secure", "concurrent"],
+  tooling: {
+    runtimes: ["Pony runtime"],
+    packageManagers: ["ponyup", "corral"],
+    ecosystems: ["Actors", "Native", "Distributed Systems"]
+  },
+  version: "0.61.1",
+  logo: "https://avatars.githubusercontent.com/u/14593805?v=4",
+  i18n: {
+    en: {
+      name: "Pony",
+      description: "An actor language with reference capabilities and data-race safety.",
+      longDescription: "Pony combines actors, object capabilities, static typing, and reference capabilities to make concurrent native programs explicit about aliasing and mutation. The language runtime schedules isolated actors that communicate by messages.\n\nIt is used for concurrent services, native experiments, actor systems, and programs that want compile-time guarantees around data races."
+    },
+    es: {
+      name: "Pony",
+      description: "Un lenguaje de actores con capacidades de referencia y seguridad ante data races.",
+      longDescription: "Pony combina actores, object capabilities, tipado estatico y capacidades de referencia para que programas nativos concurrentes sean explicitos sobre aliasing y mutacion. El runtime agenda actores aislados que se comunican por mensajes.\n\nSe usa en servicios concurrentes, experimentos nativos, sistemas de actores y programas que buscan garantias de compilacion frente a data races."
+    }
+  }
+};
+
 // src/languages/powershell.ts
 var powershell = {
   slug: "powershell",
@@ -2516,6 +3208,34 @@ var prolog = {
   }
 };
 
+// src/languages/promql.ts
+var promql = {
+  slug: "promql",
+  publishedDate: "2012-11-24",
+  extensions: [".promql"],
+  author: "Prometheus Authors",
+  website: "https://prometheus.io/docs/prometheus/latest/querying/basics/",
+  paradigms: ["query", "time-series", "declarative", "domain-specific"],
+  tooling: {
+    runtimes: ["Prometheus", "Thanos", "Mimir"],
+    ecosystems: ["Observability", "Metrics", "Monitoring"]
+  },
+  version: "Prometheus 3.x",
+  logo: "https://cdn.simpleicons.org/prometheus/E6522C",
+  i18n: {
+    en: {
+      name: "PromQL",
+      description: "The Prometheus query language for selecting and aggregating metrics.",
+      longDescription: "PromQL is the expression language used by Prometheus to select instant vectors, range vectors, scalars, and strings from time-series data. It includes label matching, arithmetic, aggregation, and functions for metric analysis.\n\nIt is used in dashboards, alerts, recording rules, troubleshooting, capacity analysis, and observability systems compatible with Prometheus queries."
+    },
+    es: {
+      name: "PromQL",
+      description: "El lenguaje de consulta de Prometheus para seleccionar y agregar metricas.",
+      longDescription: "PromQL es el lenguaje de expresiones que usa Prometheus para seleccionar vectores instantaneos, rangos, escalares y cadenas desde datos de series temporales. Incluye matching de labels, aritmetica, agregaciones y funciones para analizar metricas.\n\nSe usa en dashboards, alertas, recording rules, troubleshooting, analisis de capacidad y sistemas de observabilidad compatibles con consultas Prometheus."
+    }
+  }
+};
+
 // src/languages/protobuf.ts
 var protobuf = {
   slug: "protobuf",
@@ -2574,6 +3294,35 @@ var pug = {
   }
 };
 
+// src/languages/purescript.ts
+var purescript = {
+  slug: "purescript",
+  publishedDate: "2013-09-01",
+  extensions: [".purs"],
+  author: "Phil Freeman / PureScript contributors",
+  website: "https://www.purescript.org",
+  paradigms: ["functional", "pure", "statically typed", "declarative"],
+  tooling: {
+    runtimes: ["JavaScript", "Node.js"],
+    packageManagers: ["Spago", "npm"],
+    ecosystems: ["Web", "Functional Programming", "JavaScript"]
+  },
+  version: "0.15.15",
+  logo: "https://cdn.simpleicons.org/purescript/14161A",
+  i18n: {
+    en: {
+      name: "PureScript",
+      description: "A strongly typed purely functional language that compiles to JavaScript.",
+      longDescription: "PureScript brings algebraic data types, type classes, effects, modules, row polymorphism, and a Haskell-influenced functional model to JavaScript targets. Its compiler emits readable JavaScript and works with foreign JavaScript modules.\n\nIt is used for front-end applications, libraries, typed domain models, functional architecture, and JavaScript projects that want explicit effect handling."
+    },
+    es: {
+      name: "PureScript",
+      description: "Un lenguaje funcional puro y fuertemente tipado que compila a JavaScript.",
+      longDescription: "PureScript lleva tipos algebraicos, type classes, efectos, modulos, row polymorphism y un modelo funcional influido por Haskell a objetivos JavaScript. Su compilador emite JavaScript legible e interoperable con modulos externos.\n\nSe usa en aplicaciones front-end, bibliotecas, modelos de dominio tipados, arquitectura funcional y proyectos JavaScript que buscan manejo explicito de efectos."
+    }
+  }
+};
+
 // src/languages/python.ts
 var python = {
   slug: "python",
@@ -2632,6 +3381,35 @@ var qml = {
   }
 };
 
+// src/languages/qsharp.ts
+var qsharp = {
+  slug: "qsharp",
+  publishedDate: "2017-12-11",
+  extensions: [".qs"],
+  author: "Microsoft",
+  website: "https://learn.microsoft.com/azure/quantum/qsharp-overview",
+  paradigms: ["quantum", "domain-specific", "functional", "imperative"],
+  tooling: {
+    runtimes: ["Azure Quantum", "Q# compiler"],
+    packageManagers: ["NuGet", "Python"],
+    ecosystems: ["Quantum Computing", "Azure"]
+  },
+  version: "Q# 1.0",
+  logo: "https://github.com/microsoft.png",
+  i18n: {
+    en: {
+      name: "Q#",
+      description: "Microsoft's language for expressing quantum programs and operations.",
+      longDescription: "Q# is a quantum programming language for declaring operations, functions, qubit use, measurement, adjoints, controlled operations, and classical control around quantum routines. It is designed to model quantum algorithms separately from hardware details.\n\nIt is used for quantum algorithm development, simulation, teaching, Azure Quantum workflows, and hybrid experiments that combine classical and quantum code."
+    },
+    es: {
+      name: "Q#",
+      description: "El lenguaje de Microsoft para expresar programas y operaciones cuanticas.",
+      longDescription: "Q# es un lenguaje de programacion cuantica para declarar operaciones, funciones, uso de qubits, mediciones, adjoints, operaciones controladas y control clasico alrededor de rutinas cuanticas. Modela algoritmos cuanticos separados de detalles de hardware.\n\nSe usa en desarrollo de algoritmos cuanticos, simulacion, ensenanza, flujos de Azure Quantum y experimentos hibridos que combinan codigo clasico y cuantico."
+    }
+  }
+};
+
 // src/languages/r.ts
 var r = {
   slug: "r",
@@ -2690,6 +3468,35 @@ var racket = {
   }
 };
 
+// src/languages/raku.ts
+var raku = {
+  slug: "raku",
+  publishedDate: "2015-12-25",
+  extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"],
+  author: "Raku Community",
+  website: "https://raku.org",
+  paradigms: ["multi-paradigm", "object-oriented", "functional", "concurrent"],
+  tooling: {
+    runtimes: ["Rakudo", "MoarVM"],
+    packageManagers: ["zef"],
+    ecosystems: ["Raku", "CLI", "Text Processing"]
+  },
+  version: "6.d",
+  logo: "https://github.com/Raku.png",
+  i18n: {
+    en: {
+      name: "Raku",
+      description: "A multi-paradigm language with grammars, concurrency, and rich dispatch.",
+      longDescription: "Raku is a sibling of Perl with gradual typing, signatures, multiple dispatch, grammars, junctions, concurrency primitives, and expressive operators. It is designed for both small scripts and larger language-oriented programs.\n\nIt is used for text processing, command-line tools, parsers, automation, experimentation, and applications that benefit from built-in grammar support."
+    },
+    es: {
+      name: "Raku",
+      description: "Un lenguaje multiparadigma con grammars, concurrencia y dispatch expresivo.",
+      longDescription: "Raku es un lenguaje hermano de Perl con tipado gradual, firmas, multiple dispatch, grammars, junctions, primitivas concurrentes y operadores expresivos. Sirve tanto para scripts pequenos como para programas orientados a lenguajes.\n\nSe usa en procesamiento de texto, herramientas de linea de comandos, parsers, automatizacion, experimentacion y aplicaciones que aprovechan soporte integrado para grammars."
+    }
+  }
+};
+
 // src/languages/razor.ts
 var razor = {
   slug: "razor",
@@ -2719,6 +3526,35 @@ var razor = {
   }
 };
 
+// src/languages/reasonml.ts
+var reasonml = {
+  slug: "reasonml",
+  publishedDate: "2016-05-13",
+  extensions: [".re", ".rei"],
+  author: "Jordan Walke / Reason contributors",
+  website: "https://reasonml.github.io",
+  paradigms: ["functional", "statically typed", "multi-paradigm"],
+  tooling: {
+    runtimes: ["OCaml", "JavaScript"],
+    packageManagers: ["opam", "npm"],
+    ecosystems: ["OCaml", "JavaScript", "Web"]
+  },
+  version: "3.13.0",
+  logo: "https://cdn.simpleicons.org/reason/DD4B39",
+  i18n: {
+    en: {
+      name: "ReasonML",
+      description: "A JavaScript-like syntax for OCaml and typed functional programming.",
+      longDescription: "ReasonML is a syntax layer for OCaml that presents familiar braces and punctuation while retaining OCaml's modules, pattern matching, type inference, and functional foundations. It has been used with native OCaml and JavaScript compilation workflows.\n\nIt is used in OCaml-adjacent projects, typed UI code, libraries, and codebases that prefer Reason syntax over traditional OCaml syntax."
+    },
+    es: {
+      name: "ReasonML",
+      description: "Una sintaxis cercana a JavaScript para OCaml y programacion funcional tipada.",
+      longDescription: "ReasonML es una capa de sintaxis para OCaml que presenta llaves y puntuacion familiares conservando modulos, pattern matching, inferencia de tipos y bases funcionales de OCaml. Se ha usado con flujos nativos y de compilacion a JavaScript.\n\nSe usa en proyectos cercanos a OCaml, UI tipada, bibliotecas y codebases que prefieren la sintaxis Reason frente a la sintaxis tradicional de OCaml."
+    }
+  }
+};
+
 // src/languages/rego.ts
 var rego = {
   slug: "rego",
@@ -2748,6 +3584,64 @@ var rego = {
   }
 };
 
+// src/languages/rescript.ts
+var rescript = {
+  slug: "rescript",
+  publishedDate: "2020-07-01",
+  extensions: [".res", ".resi"],
+  author: "ReScript Association",
+  website: "https://rescript-lang.org",
+  paradigms: ["functional", "statically typed", "multi-paradigm", "javascript-targeted"],
+  tooling: {
+    runtimes: ["JavaScript", "Node.js", "Browser"],
+    packageManagers: ["npm", "pnpm", "Yarn"],
+    ecosystems: ["Web", "React", "JavaScript"]
+  },
+  version: "12.0.0",
+  logo: "https://cdn.simpleicons.org/rescript/E6484A",
+  i18n: {
+    en: {
+      name: "ReScript",
+      description: "A typed language and compiler focused on ergonomic JavaScript output.",
+      longDescription: "ReScript is a statically typed language for JavaScript targets with pattern matching, variants, modules, records, interop annotations, and a syntax tuned for web development. Its compiler and build tools focus on predictable generated JavaScript.\n\nIt is used in front-end applications, React codebases, shared libraries, and JavaScript projects that want compact type-safe source with explicit interop."
+    },
+    es: {
+      name: "ReScript",
+      description: "Un lenguaje tipado y compilador enfocado en generar JavaScript ergonomico.",
+      longDescription: "ReScript es un lenguaje de tipado estatico para objetivos JavaScript con pattern matching, variants, modulos, records, anotaciones de interop y una sintaxis ajustada al desarrollo web. Su compilador y herramientas buscan JavaScript generado predecible.\n\nSe usa en aplicaciones front-end, codebases React, bibliotecas compartidas y proyectos JavaScript que buscan fuente compacta y segura con interop explicito."
+    }
+  }
+};
+
+// src/languages/restructuredtext.ts
+var restructuredtext = {
+  slug: "restructuredtext",
+  publishedDate: "2001-06-01",
+  extensions: [".rst", ".rest"],
+  author: "David Goodger / Docutils contributors",
+  website: "https://docutils.sourceforge.io/rst.html",
+  paradigms: ["markup", "declarative", "documentation"],
+  tooling: {
+    runtimes: ["Docutils", "Sphinx"],
+    packageManagers: ["pip"],
+    ecosystems: ["Python", "Documentation", "Publishing"]
+  },
+  version: "Docutils 0.22.2",
+  logo: "https://cdn.simpleicons.org/readthedocs/8CA1AF",
+  i18n: {
+    en: {
+      name: "reStructuredText",
+      description: "A plain-text markup format used by Docutils and Sphinx documentation.",
+      longDescription: "reStructuredText is a structured plain-text markup language with sections, directives, roles, references, tables, lists, and extension points. Docutils defines the parser model and Sphinx extends it for technical documentation.\n\nIt is used for Python documentation, manuals, API references, books, project notes, and publishing workflows that need semantic markup from readable text."
+    },
+    es: {
+      name: "reStructuredText",
+      description: "Un formato de marcado en texto plano usado por Docutils y Sphinx.",
+      longDescription: "reStructuredText es un lenguaje de marcado estructurado en texto plano con secciones, directives, roles, referencias, tablas, listas y puntos de extension. Docutils define su modelo de parser y Sphinx lo extiende para documentacion tecnica.\n\nSe usa en documentacion Python, manuales, referencias API, libros, notas de proyectos y flujos de publicacion que necesitan marcado semantico desde texto legible."
+    }
+  }
+};
+
 // src/languages/ruby.ts
 var ruby = {
   slug: "ruby",
@@ -2806,6 +3700,34 @@ var rust = {
   }
 };
 
+// src/languages/sas.ts
+var sas = {
+  slug: "sas",
+  publishedDate: "1976-01-01",
+  extensions: [".sas"],
+  author: "SAS Institute",
+  website: "https://www.sas.com",
+  paradigms: ["data-step", "procedural", "statistical", "domain-specific"],
+  tooling: {
+    runtimes: ["SAS 9", "SAS Viya"],
+    ecosystems: ["Analytics", "Statistics", "Enterprise Data"]
+  },
+  version: "SAS 9.4",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/1/10/SAS_logo_horiz.svg",
+  i18n: {
+    en: {
+      name: "SAS",
+      description: "A language and system for statistical analysis and data processing.",
+      longDescription: "SAS programs combine DATA steps, procedures, macros, formats, libraries, and analytics-oriented statements to transform and analyze data. The language is tightly linked to the SAS platform and its statistical tooling.\n\nIt is used in analytics, regulated reporting, clinical workflows, data preparation, forecasting, and enterprise statistical systems."
+    },
+    es: {
+      name: "SAS",
+      description: "Un lenguaje y sistema para analisis estadistico y procesamiento de datos.",
+      longDescription: "Los programas SAS combinan DATA steps, procedimientos, macros, formatos, libraries y sentencias orientadas a analitica para transformar y analizar datos. El lenguaje esta ligado a la plataforma SAS y su tooling estadistico.\n\nSe usa en analitica, reportes regulados, flujos clinicos, preparacion de datos, pronosticos y sistemas estadisticos empresariales."
+    }
+  }
+};
+
 // src/languages/scala.ts
 var scala = {
   slug: "scala",
@@ -2835,6 +3757,34 @@ var scala = {
   }
 };
 
+// src/languages/scheme.ts
+var scheme = {
+  slug: "scheme",
+  publishedDate: "1975-12-01",
+  extensions: [".scm", ".ss", ".sld", ".sls"],
+  author: "Guy L. Steele Jr. / Gerald Jay Sussman",
+  website: "https://www.scheme.org",
+  paradigms: ["functional", "lisp", "minimal", "multi-paradigm"],
+  tooling: {
+    runtimes: ["Chez Scheme", "Guile", "Racket", "Chicken"],
+    ecosystems: ["Lisp", "Education", "Language Research"]
+  },
+  version: "R7RS small",
+  logo: "https://cdn.simpleicons.org/racket/9F1D20",
+  i18n: {
+    en: {
+      name: "Scheme",
+      description: "A small Lisp family language centered on lexical scope and procedures.",
+      longDescription: "Scheme is a Lisp dialect known for a compact core, lexical scoping, first-class procedures, macros, continuations, and a tradition of language experimentation. Standards define a portable base while implementations add libraries and tooling.\n\nIt is used in teaching, compilers, scripting, research, embedded extension systems, and programs that value a small expressive language core."
+    },
+    es: {
+      name: "Scheme",
+      description: "Un lenguaje de la familia Lisp centrado en alcance lexico y procedimientos.",
+      longDescription: "Scheme es un dialecto Lisp conocido por un nucleo compacto, alcance lexico, procedimientos de primera clase, macros, continuations y una tradicion de experimentacion con lenguajes. Los estandares definen una base portable mientras las implementaciones agregan bibliotecas.\n\nSe usa en ensenanza, compiladores, scripting, investigacion, sistemas de extension embebidos y programas que valoran un nucleo expresivo pequeno."
+    }
+  }
+};
+
 // src/languages/scss.ts
 var scss = {
   slug: "scss",
@@ -2864,6 +3814,63 @@ var scss = {
   }
 };
 
+// src/languages/smalltalk.ts
+var smalltalk = {
+  slug: "smalltalk",
+  publishedDate: "1972-01-01",
+  extensions: [".st"],
+  author: "Alan Kay / Dan Ingalls / Adele Goldberg",
+  website: "https://squeak.org",
+  paradigms: ["object-oriented", "message-passing", "reflective", "dynamic"],
+  tooling: {
+    runtimes: ["Pharo", "Squeak", "GNU Smalltalk"],
+    ecosystems: ["Images", "Education", "Object Systems"]
+  },
+  version: "ANSI INCITS 319-1998",
+  logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Smalltalk_Balloon.svg",
+  i18n: {
+    en: {
+      name: "Smalltalk",
+      description: "A message-oriented object language with live image-based environments.",
+      longDescription: "Smalltalk helped define object-oriented programming through message sends, classes, blocks, reflection, and interactive image environments. Many implementations pair the language with live browsers, inspectors, and debuggers.\n\nIt is used for education, research, long-lived business systems, simulations, and exploratory programming inside live object images."
+    },
+    es: {
+      name: "Smalltalk",
+      description: "Un lenguaje orientado a mensajes y objetos con entornos de imagen vivos.",
+      longDescription: "Smalltalk ayudo a definir la programacion orientada a objetos mediante mensajes, clases, bloques, reflexion y entornos interactivos basados en imagenes. Muchas implementaciones combinan el lenguaje con browsers, inspectors y debuggers vivos.\n\nSe usa en educacion, investigacion, sistemas de negocio longevos, simulaciones y programacion exploratoria dentro de imagenes de objetos."
+    }
+  }
+};
+
+// src/languages/smarty.ts
+var smarty = {
+  slug: "smarty",
+  publishedDate: "2001-01-01",
+  extensions: [".tpl", ".smarty"],
+  author: "Monte Ohrt / Andrei Zmievski / Smarty contributors",
+  website: "https://www.smarty.net",
+  paradigms: ["templating", "declarative", "markup"],
+  tooling: {
+    runtimes: ["PHP"],
+    packageManagers: ["Composer"],
+    ecosystems: ["PHP", "Web"]
+  },
+  version: "5.5.1",
+  logo: "https://www.smarty.net/images/logo_print.gif",
+  i18n: {
+    en: {
+      name: "Smarty",
+      description: "A PHP template language for presentation logic and reusable views.",
+      longDescription: "Smarty is a PHP templating system with tags, modifiers, functions, plugins, inheritance, and caching features for separating presentation templates from application code. Templates are compiled for execution by PHP.\n\nIt is used in PHP applications, themes, CMS views, emails, and server-rendered web projects that maintain separate template files."
+    },
+    es: {
+      name: "Smarty",
+      description: "Un lenguaje de plantillas PHP para logica de presentacion y vistas reutilizables.",
+      longDescription: "Smarty es un sistema de plantillas PHP con tags, modifiers, funciones, plugins, herencia y cache para separar plantillas de presentacion del codigo de aplicacion. Las plantillas se compilan para ejecutarse con PHP.\n\nSe usa en aplicaciones PHP, temas, vistas de CMS, emails y proyectos web renderizados en servidor que mantienen archivos de plantillas separados."
+    }
+  }
+};
+
 // src/languages/solidity.ts
 var solidity = {
   slug: "solidity",
@@ -2917,6 +3924,34 @@ var sql = {
   }
 };
 
+// src/languages/standard-ml.ts
+var standardMl = {
+  slug: "standard-ml",
+  publishedDate: "1990-01-01",
+  extensions: [".sml", ".sig", ".fun"],
+  author: "Robin Milner and collaborators",
+  website: "https://smlfamily.github.io",
+  paradigms: ["functional", "statically typed", "module-oriented"],
+  tooling: {
+    runtimes: ["MLton", "Standard ML of New Jersey", "Poly/ML"],
+    ecosystems: ["ML", "Compilers", "Research"]
+  },
+  version: "The Definition 1997",
+  logo: "https://avatars.githubusercontent.com/u/62883579?v=4",
+  i18n: {
+    en: {
+      name: "Standard ML",
+      description: "A statically typed ML language with modules and pattern matching.",
+      longDescription: "Standard ML defines a strict functional language with algebraic datatypes, pattern matching, type inference, exceptions, and a strong module system with signatures and functors. Its formal definition shaped much ML-family work.\n\nIt is used in compilers, theorem tools, teaching, research, and projects that need a small typed functional core with robust modules."
+    },
+    es: {
+      name: "Standard ML",
+      description: "Un lenguaje ML tipado con modulos y pattern matching.",
+      longDescription: "Standard ML define un lenguaje funcional estricto con datatypes algebraicos, pattern matching, inferencia de tipos, excepciones y un sistema fuerte de modulos con signatures y functors. Su definicion formal influyo mucho en la familia ML.\n\nSe usa en compiladores, herramientas de teoremas, ensenanza, investigacion y proyectos que necesitan un nucleo funcional tipado con modulos robustos."
+    }
+  }
+};
+
 // src/languages/starlark.ts
 var starlark = {
   slug: "starlark",
@@ -2946,6 +3981,63 @@ var starlark = {
   }
 };
 
+// src/languages/stata.ts
+var stata = {
+  slug: "stata",
+  publishedDate: "1985-01-01",
+  extensions: [".do", ".ado", ".mata"],
+  author: "StataCorp",
+  website: "https://www.stata.com",
+  paradigms: ["statistical", "scripting", "data-analysis", "domain-specific"],
+  tooling: {
+    runtimes: ["Stata"],
+    ecosystems: ["Statistics", "Econometrics", "Research"]
+  },
+  version: "19",
+  logo: "https://www.stata.com/includes/images/stata-logo-blue.svg",
+  i18n: {
+    en: {
+      name: "Stata",
+      description: "A command language for statistical analysis, data management, and graphics.",
+      longDescription: "Stata commands and do-files cover data preparation, estimation, graphics, reporting, and programmable workflows, with Mata available for matrix-oriented programming. The language is tied to the Stata statistical environment.\n\nIt is used in economics, public health, social science, policy analysis, teaching, and reproducible statistical research."
+    },
+    es: {
+      name: "Stata",
+      description: "Un lenguaje de comandos para analisis estadistico, datos y graficos.",
+      longDescription: "Los comandos y do-files de Stata cubren preparacion de datos, estimacion, graficos, reportes y flujos programables, con Mata para programacion orientada a matrices. El lenguaje esta ligado al entorno estadistico Stata.\n\nSe usa en economia, salud publica, ciencias sociales, analisis de politicas, ensenanza e investigacion estadistica reproducible."
+    }
+  }
+};
+
+// src/languages/stylus.ts
+var stylus = {
+  slug: "stylus",
+  publishedDate: "2010-12-01",
+  extensions: [".styl"],
+  author: "TJ Holowaychuk / Stylus contributors",
+  website: "https://stylus-lang.com",
+  paradigms: ["stylesheet", "declarative", "preprocessor"],
+  tooling: {
+    runtimes: ["Node.js"],
+    packageManagers: ["npm", "pnpm", "Yarn"],
+    ecosystems: ["CSS", "Web"]
+  },
+  version: "0.64.0",
+  logo: "https://cdn.simpleicons.org/stylus/333333",
+  i18n: {
+    en: {
+      name: "Stylus",
+      description: "A flexible CSS preprocessor with optional punctuation and indentation syntax.",
+      longDescription: "Stylus extends stylesheet authoring with variables, mixins, functions, imports, nesting, and a syntax that can omit braces, colons, and semicolons. It compiles authoring files into CSS.\n\nIt is used in web styling pipelines, design systems, legacy front-end builds, and projects that prefer concise stylesheet syntax."
+    },
+    es: {
+      name: "Stylus",
+      description: "Un preprocesador CSS flexible con puntuacion opcional y sintaxis por indentacion.",
+      longDescription: "Stylus extiende la autoria de estilos con variables, mixins, funciones, imports, nesting y una sintaxis que puede omitir llaves, dos puntos y punto y coma. Compila archivos de autoria hacia CSS.\n\nSe usa en pipelines de estilos web, sistemas de diseno, builds front-end heredados y proyectos que prefieren sintaxis de hojas de estilo concisa."
+    }
+  }
+};
+
 // src/languages/svelte.ts
 var svelte = {
   slug: "svelte",
@@ -3118,6 +4210,63 @@ var tex = {
   }
 };
 
+// src/languages/thrift.ts
+var thrift = {
+  slug: "thrift",
+  publishedDate: "2007-04-01",
+  extensions: [".thrift"],
+  author: "Facebook / Apache Software Foundation",
+  website: "https://thrift.apache.org",
+  paradigms: ["interface-definition", "schema", "declarative", "rpc"],
+  tooling: {
+    runtimes: ["Apache Thrift Runtime"],
+    packageManagers: ["Maven", "npm", "PyPI", "Go modules"],
+    ecosystems: ["RPC", "APIs", "Distributed Systems"]
+  },
+  version: "0.22.0",
+  logo: "https://cdn.simpleicons.org/apache/D22128",
+  i18n: {
+    en: {
+      name: "Apache Thrift",
+      description: "An IDL for cross-language services and serializable data types.",
+      longDescription: "Thrift files define services, structs, fields, enums, exceptions, namespaces, and wire-level choices that generators turn into code for many languages. The project includes protocols and transports for RPC use.\n\nIt is used for service contracts, schema sharing, code generation, distributed systems, and cross-language APIs."
+    },
+    es: {
+      name: "Apache Thrift",
+      description: "Un IDL para servicios entre lenguajes y tipos de datos serializables.",
+      longDescription: "Los archivos Thrift definen servicios, structs, campos, enums, excepciones, namespaces y decisiones de wire que los generadores convierten en codigo para muchos lenguajes. El proyecto incluye protocolos y transports para RPC.\n\nSe usa en contratos de servicios, schemas compartidos, generacion de codigo, sistemas distribuidos y APIs entre lenguajes."
+    }
+  }
+};
+
+// src/languages/tla-plus.ts
+var tlaPlus = {
+  slug: "tla-plus",
+  publishedDate: "1999-01-01",
+  extensions: [".tla"],
+  author: "Leslie Lamport",
+  website: "https://lamport.azurewebsites.net/tla/tla.html",
+  paradigms: ["specification", "formal-methods", "temporal-logic", "declarative"],
+  tooling: {
+    runtimes: ["TLC", "TLA+ Toolbox", "Apalache"],
+    ecosystems: ["Formal Methods", "Distributed Systems", "Verification"]
+  },
+  version: "TLA+ 2",
+  logo: "https://avatars.githubusercontent.com/u/315978?v=4",
+  i18n: {
+    en: {
+      name: "TLA+",
+      description: "A formal specification language for state machines and temporal properties.",
+      longDescription: "TLA+ describes systems as mathematical state transitions with actions, invariants, temporal formulas, modules, and refinement-oriented specifications. Tooling such as TLC explores behaviors to check models.\n\nIt is used to reason about distributed algorithms, protocols, concurrency, safety properties, design reviews, and systems where a precise specification catches failures early."
+    },
+    es: {
+      name: "TLA+",
+      description: "Un lenguaje de especificacion formal para estados y propiedades temporales.",
+      longDescription: "TLA+ describe sistemas como transiciones matematicas de estado con acciones, invariantes, formulas temporales, modulos y especificaciones orientadas a refinamiento. Herramientas como TLC exploran comportamientos para revisar modelos.\n\nSe usa para razonar sobre algoritmos distribuidos, protocolos, concurrencia, propiedades de seguridad, revisiones de diseno y sistemas donde una especificacion precisa detecta fallos temprano."
+    }
+  }
+};
+
 // src/languages/toml.ts
 var toml = {
   slug: "toml",
@@ -3229,6 +4378,64 @@ var typst = {
   }
 };
 
+// src/languages/v.ts
+var v = {
+  slug: "v",
+  publishedDate: "2019-06-20",
+  extensions: [".v", ".vsh"],
+  author: "Alexander Medvednikov / V contributors",
+  website: "https://vlang.io",
+  paradigms: ["imperative", "systems", "multi-paradigm", "statically typed"],
+  tooling: {
+    runtimes: ["V compiler"],
+    packageManagers: ["vpm"],
+    ecosystems: ["Native", "Web", "Systems"]
+  },
+  version: "weekly.2025.49",
+  logo: "https://cdn.simpleicons.org/v/5D87BF",
+  i18n: {
+    en: {
+      name: "V",
+      description: "A compiled statically typed language for simple native application builds.",
+      longDescription: "V is a compiled language with modules, sum types, generics, concurrency syntax, C interop, and a toolchain that emphasizes quick compilation and small deployment workflows. It targets C and native outputs through its compiler.\n\nIt is used for command-line tools, native applications, experiments, web services, and projects that prefer an integrated lightweight toolchain."
+    },
+    es: {
+      name: "V",
+      description: "Un lenguaje compilado y tipado para construir aplicaciones nativas simples.",
+      longDescription: "V es un lenguaje compilado con modulos, sum types, generics, sintaxis concurrente, interop con C y un toolchain que enfatiza compilacion rapida y despliegues pequenos. Su compilador apunta a C y salidas nativas.\n\nSe usa en herramientas de linea de comandos, aplicaciones nativas, experimentos, servicios web y proyectos que prefieren un toolchain ligero e integrado."
+    }
+  }
+};
+
+// src/languages/vala.ts
+var vala = {
+  slug: "vala",
+  publishedDate: "2006-07-15",
+  extensions: [".vala", ".vapi"],
+  author: "Jurg Billeter / GNOME contributors",
+  website: "https://vala.dev",
+  paradigms: ["object-oriented", "statically typed", "gnome", "c-targeted"],
+  tooling: {
+    runtimes: ["GLib", "GObject"],
+    packageManagers: ["Meson", "pkg-config"],
+    ecosystems: ["GNOME", "GTK", "Native"]
+  },
+  version: "0.56.18",
+  logo: "https://cdn.simpleicons.org/gnome/4A86CF",
+  i18n: {
+    en: {
+      name: "Vala",
+      description: "A GNOME-oriented language that compiles high-level syntax to C.",
+      longDescription: "Vala provides classes, interfaces, properties, generics, signals, and async syntax over GLib and GObject conventions, compiling source into C. VAPI files describe bindings to existing C libraries.\n\nIt is used for GTK applications, GNOME libraries, native tools, bindings, and projects that want high-level source while integrating with C APIs."
+    },
+    es: {
+      name: "Vala",
+      description: "Un lenguaje orientado a GNOME que compila sintaxis de alto nivel a C.",
+      longDescription: "Vala ofrece clases, interfaces, propiedades, generics, signals y sintaxis async sobre las convenciones de GLib y GObject, compilando fuente hacia C. Los archivos VAPI describen bindings a bibliotecas C existentes.\n\nSe usa en aplicaciones GTK, bibliotecas GNOME, herramientas nativas, bindings y proyectos que buscan fuente de alto nivel integrada con APIs C."
+    }
+  }
+};
+
 // src/languages/verilog.ts
 var verilog = {
   slug: "verilog",
@@ -3345,6 +4552,35 @@ var vue = {
   }
 };
 
+// src/languages/vyper.ts
+var vyper = {
+  slug: "vyper",
+  publishedDate: "2017-07-19",
+  extensions: [".vy"],
+  author: "Vyper contributors",
+  website: "https://vyperlang.org",
+  paradigms: ["smart-contract", "statically typed", "domain-specific", "imperative"],
+  tooling: {
+    runtimes: ["Ethereum Virtual Machine"],
+    packageManagers: ["pip", "uv"],
+    ecosystems: ["Ethereum", "Smart Contracts", "Web3"]
+  },
+  version: "0.4.3",
+  logo: "https://avatars.githubusercontent.com/u/37288461?v=4",
+  i18n: {
+    en: {
+      name: "Vyper",
+      description: "A Pythonic smart contract language for the Ethereum Virtual Machine.",
+      longDescription: "Vyper is a contract language for Ethereum that favors explicit behavior, bounds, and auditability over broad language surface area. Its syntax is Python-like while its compiler emits EVM bytecode.\n\nIt is used for Ethereum smart contracts, financial protocols, on-chain experiments, and codebases that prefer a deliberately constrained contract language."
+    },
+    es: {
+      name: "Vyper",
+      description: "Un lenguaje de smart contracts con sintaxis Python para Ethereum.",
+      longDescription: "Vyper es un lenguaje de contratos para Ethereum que favorece comportamiento explicito, limites y auditabilidad sobre una superficie amplia del lenguaje. Su sintaxis es parecida a Python y su compilador emite bytecode EVM.\n\nSe usa en smart contracts de Ethereum, protocolos financieros, experimentos on-chain y codebases que prefieren un lenguaje de contratos deliberadamente restringido."
+    }
+  }
+};
+
 // src/languages/webassembly.ts
 var webassembly = {
   slug: "webassembly",
@@ -3403,6 +4639,34 @@ var wgsl = {
   }
 };
 
+// src/languages/wren.ts
+var wren = {
+  slug: "wren",
+  publishedDate: "2013-10-31",
+  extensions: [".wren"],
+  author: "Bob Nystrom / Wren contributors",
+  website: "https://wren.io",
+  paradigms: ["object-oriented", "scripting", "class-based", "dynamic"],
+  tooling: {
+    runtimes: ["Wren VM"],
+    ecosystems: ["Embedding", "Games", "Scripting"]
+  },
+  version: "0.4.0",
+  logo: "https://avatars.githubusercontent.com/u/8763410?v=4",
+  i18n: {
+    en: {
+      name: "Wren",
+      description: "A small class-based scripting language designed for embedding.",
+      longDescription: "Wren is a compact dynamic language with classes, fibers, modules, closures, and a VM intended to embed cleanly in host applications. Its syntax keeps scripting programs short while preserving an object-oriented model.\n\nIt is used for embedded scripting, game experiments, tools, teaching, and applications that need a small embeddable language runtime."
+    },
+    es: {
+      name: "Wren",
+      description: "Un lenguaje pequeno de scripting basado en clases y pensado para embeberse.",
+      longDescription: "Wren es un lenguaje dinamico compacto con clases, fibers, modulos, closures y una VM pensada para integrarse limpiamente en aplicaciones anfitrionas. Su sintaxis mantiene scripts breves y conserva un modelo orientado a objetos.\n\nSe usa en scripting embebido, experimentos de juegos, herramientas, ensenanza y aplicaciones que necesitan un runtime de lenguaje pequeno."
+    }
+  }
+};
+
 // src/languages/xaml.ts
 var xaml = {
   slug: "xaml",
@@ -3537,6 +4801,35 @@ var yaml = {
   }
 };
 
+// src/languages/zeek.ts
+var zeek = {
+  slug: "zeek",
+  publishedDate: "1995-01-01",
+  extensions: [".zeek", ".bro"],
+  author: "Vern Paxson / Zeek Project",
+  website: "https://zeek.org",
+  paradigms: ["event-driven", "network-analysis", "domain-specific", "scripting"],
+  tooling: {
+    runtimes: ["Zeek"],
+    packageManagers: ["zkg"],
+    ecosystems: ["Network Security", "Observability", "Incident Response"]
+  },
+  version: "8.0.4",
+  logo: "https://avatars.githubusercontent.com/u/10666805?v=4",
+  i18n: {
+    en: {
+      name: "Zeek",
+      description: "An event-driven scripting language for network analysis and security policy.",
+      longDescription: "Zeek scripts describe events, records, analyzers, notices, logging, and policy logic over network traffic observed by the Zeek monitor. The language lets analysts extend protocol and detection behavior.\n\nIt is used in network security monitoring, incident response, traffic analysis, telemetry pipelines, and site-specific security policy."
+    },
+    es: {
+      name: "Zeek",
+      description: "Un lenguaje event-driven para analisis de red y politicas de seguridad.",
+      longDescription: "Los scripts Zeek describen eventos, records, analyzers, notices, logging y logica de politica sobre trafico de red observado por el monitor Zeek. El lenguaje permite extender comportamiento de protocolos y deteccion.\n\nSe usa en monitoreo de seguridad de red, respuesta a incidentes, analisis de trafico, pipelines de telemetria y politicas de seguridad especificas del sitio."
+    }
+  }
+};
+
 // src/languages/zig.ts
 var zig = {
   slug: "zig",
@@ -3566,6 +4859,34 @@ var zig = {
   }
 };
 
+// src/languages/ziggy.ts
+var ziggy = {
+  slug: "ziggy",
+  publishedDate: "2023-10-02",
+  extensions: [".ziggy", ".ziggy-schema"],
+  author: "Loris Cro",
+  website: "https://ziggy-lang.io",
+  paradigms: ["data-notation", "schema", "declarative", "configuration"],
+  tooling: {
+    runtimes: ["Ziggy CLI"],
+    ecosystems: ["Configuration", "Data Formats", "Zig"]
+  },
+  version: "0.1.0",
+  logo: "https://avatars.githubusercontent.com/u/1642052?v=4",
+  i18n: {
+    en: {
+      name: "Ziggy",
+      description: "A data notation and schema language for configuration-style documents.",
+      longDescription: "Ziggy is a data language for readable structured documents with a companion schema form for describing expected shapes. It targets configuration and data interchange workflows with tooling around Zig ecosystems.\n\nIt is used for configuration files, schema-checked data documents, tooling experiments, and projects that want a compact typed data notation."
+    },
+    es: {
+      name: "Ziggy",
+      description: "Una notacion de datos y schemas para documentos de configuracion.",
+      longDescription: "Ziggy es un lenguaje de datos para documentos estructurados legibles con una forma de schema complementaria para describir shapes esperados. Apunta a configuracion e intercambio de datos con tooling cercano al ecosistema Zig.\n\nSe usa en archivos de configuracion, documentos de datos validados por schemas, experimentos de tooling y proyectos que buscan una notacion de datos compacta y tipada."
+    }
+  }
+};
+
 // src/languages/zsh.ts
 var zsh = {
   slug: "zsh",
@@ -3600,6 +4921,7 @@ var languages = [
   abap,
   actionscript,
   ada,
+  agda,
   antlr,
   apex,
   apl,
@@ -3617,11 +4939,15 @@ var languages = [
   bicep,
   blade,
   c,
+  carbon,
+  chapel,
+  circom,
   cmake,
   clojure,
   coffeescript,
   coldfusion,
   cobol,
+  coq,
   cpp,
   csharp,
   crystal,
@@ -3631,7 +4957,10 @@ var languages = [
   cython,
   d,
   dart,
+  dhall,
+  dita,
   dockerfile,
+  earthly,
   elixir,
   elm,
   erb,
@@ -3649,79 +4978,117 @@ var languages = [
   graphql,
   groovy,
   handlebars,
+  hack,
+  haml,
   haskell,
   haxe,
   hcl,
   hlsl,
   html,
+  idris,
   ini,
   java,
   javascript,
+  janet,
   jinja,
   json,
   jsonnet,
   jupyterNotebook,
   julia,
   kotlin,
+  lean,
   less,
   liquid,
   lisp,
+  llvmIr,
   lua,
+  luau,
+  mako,
   makefile,
+  mathematica,
   matlab,
   markdown,
   mdx,
   mermaid,
   meson,
   metal,
+  mojo,
+  moonbit,
   svn,
   nginx,
   nim,
   nix,
   ocaml,
   objectiveC,
+  odin,
+  opencl,
   pascal,
   perl,
   php,
+  pineScript,
   plantuml,
+  plsql,
+  pony,
   powershell,
   prolog,
+  promql,
   protobuf,
   pug,
+  purescript,
   python,
   qml,
+  qsharp,
   r,
+  raku,
   racket,
   razor,
+  reasonml,
   rego,
+  rescript,
+  restructuredtext,
   ruby,
   rust,
+  sas,
   scala,
   scss,
+  scheme,
+  smalltalk,
+  smarty,
   solidity,
   sql,
+  standardMl,
   starlark,
+  stata,
+  stylus,
   svg,
   svelte,
   swift,
   tcl,
   tex,
+  thrift,
+  tlaPlus,
   toml,
   twig,
   typescript,
   typst,
+  v,
+  vala,
   verilog,
   vhdl,
   visualBasic,
   vue,
+  vyper,
   webassembly,
   wgsl,
+  wren,
   xaml,
   xml,
   xquery,
   xslt,
   yaml,
+  zeek,
   zig,
+  ziggy,
   zsh
 ];