Emerging Programming Languages 2022–2026

A survey of programming languages that had their first public release, or a substantial redesign / major version, between 2022 and 2026 (inclusive). Present date: September 12, 2026.

Method and grounding. Every value below was taken from a page fetched during this research session. Official language sites, maintainer blogs, published papers (arXiv, journals), and primary repositories are preferred. GitHub’s /commits/... HTML pages are blocked to automated fetching (disallow_by_robots), so repository activity was read directly from the GitHub REST API for each repository listed (repos/{owner}/{repo}, repos/{owner}/{repo}/commits, repos/{owner}/{repo}/releases), inspected on September 12, 2026; the linked repository page is the repository that was inspected. Where a value could not be confirmed from a fetched source it is written n.a. rather than guessed.

Sections: 47 languages. Exclusions and judgment calls are documented at the end.


Contents

Hylo · Roc · Koka · Austral · Inko · Gleam · Unison · Mojo · MoonBit · Verse · Bend / HVM2 · Carbon · Vale · Flix · Effekt · Ante · Grain · Toka · Pel · Cangjie · Pkl · Lean 4 · Idris 2 · Rocq · Swift 6 · Kotlin 2.0 · Dart 3 · Nim 2 · Zig · Odin · Hare · Cairo · Noir · Sway · Leo · Juvix · Wing · Onyx · Amber · Neut · C3 · Jakt · Motoko · Granule · Rust (2024 edition) · TypeScript 5 / 7 · ReScript


Hylo

  • Website / repo: hylo-lang.org, github.com/hylo-lang/hylo
  • Summary: Hylo is “a programming language that leverages mutable value semantics and generic programming for high-level systems programming” (Hylo introduction). It is positioned as “a zero-cost abstraction language that fully acknowledges the physical constraints of computer architecture” while still presenting a value-oriented user model (Hylo introduction). Its lineage is explicitly Swift-derived: “Hylo borrows heavily from Swift which has demonstrated a user-friendly approach to generic programming and deep support for value semantics,” while “de-emphasizing reference semantics and avoiding the complexities that result from trying to make it statically safe (e.g., memory regions, lifetime annotations, etc.)” (Hylo introduction). The site names Rust, Zig and Vale as overlapping efforts (Hylo introduction). The developing organization is not named on the official site; the compiler is “open source and hosted on GitHub” (Hylo introduction).
  • Most distinctive idea: “What sets Hylo apart in the current landscape is its focus on mutable value semantics for the purpose of writing efficient, generic code” (Hylo introduction) — the surface language is built on values with in-place mutation instead of a reference/lifetime discipline. The homepage banner states the same commitment: “All in on Value Semantics and Generic Programming” (hylo-lang.org).
  • Maturity:
    • Release stage: research prototype / pre-alpha. “Hylo is under active development and is not ready to be used yet” (Hylo introduction); “the compiler and standard library are still in their early stages” (hylo-lang.org). The only tag published on the repository is v-old-0.0.42, published 2026-05-14 (hylo-lang/hylo releases).
    • Activity in 2026: active but slowed — repository last pushed 2026-09-07, most recent commit on the default branch 2026-07-13, 1,558 stars (hylo-lang/hylo).
  • Relevance to AI-agent-written code: Mutable value semantics removes the single hardest thing for a code generator to get right in Rust-style systems languages — aliasing and lifetime annotations — because there are no reference types to annotate in the surface language. An agent can emit straightforward value-passing code and the compiler still rejects the aliasing violations that would be memory-unsafety in C++. The downside is corpus size: Hylo is pre-alpha with a tiny public code corpus, so agents have little idiomatic material to imitate and will hallucinate syntax that does not exist. Its Swift lineage partially mitigates this, since Swift-shaped generics and value semantics are well represented in training data.

Roc

  • Website / repo: roc-lang.org, github.com/roc-lang/roc
  • Summary: Roc describes itself as “A fast, friendly, functional language” whose “syntax, semantics, and included toolset all prioritize user-friendliness” (roc-lang.org). It compiles ahead of time: “Roc code is designed to build fast and run fast. It compiles to machine code or WebAssembly” (roc-lang.org). Governance sits with the Roc Programming Language Foundation, “a registered US 501(c)(3) nonprofit organization,” with Richard Feldman as the principal contributor and Lambda Class, ohne-makler and Martian as corporate sponsors (roc-lang.org). The site is candid about scale: “We are a small group trying to do big things” (roc-lang.org).
  • Most distinctive idea: Roc’s compiler is deployable as a pure-frontend artifact — “You can run the full compiler in the browser without a backend server!” (roc-lang.org) — and the site’s examples are “built and tested with the same Roc compiler as this website” (roc-lang.org). The official pages fetched do not name a single distinctive semantic idea beyond friendliness and fast native/Wasm compilation, so a stronger claim would be unsupported.
  • Maturity:
    • Release stage: alpha. “Roc is a Work in Progress!” (Roc install page). The most recent published release channel is alpha4-rolling, published 2025-08-26; earlier channels are alpha3-rolling (2025-02-26) and 0.0.0-alpha1 (2025-01-29) (roc-lang/roc releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with a commit on the default branch the same day (2026-09-12), 6,043 stars (roc-lang/roc).
  • Relevance to AI-agent-written code: A deliberately small, one-obvious-way functional language with ahead-of-time compilation is a good fit for agent generation: fewer constructs means fewer opportunities to hallucinate, and a compile step catches type errors before anything runs. The browser-embeddable compiler is directly useful for agent loops, since an agent can typecheck candidate programs without provisioning a toolchain. The main hindrance is churn: an alpha language whose semantics are still moving means agent-generated code trained on older snapshots will not compile.

Koka

  • Website / repo: koka-lang.github.io/koka, github.com/koka-lang/koka
  • Summary: Koka is “a strongly typed functional-style language with effect types and handlers” that “separates pure values from side-effecting computation” (Koka book). The book is authored by Daan Leijen and dated 2026-03-17, and the design rests on a chain of Microsoft Research technical reports including “Generalized Evidence Passing for Effect Handlers,” “Reference Counting with Frame Limited Reuse” (MSR-TR-2021-30) and “FP²: Fully in-Place Functional Programming” (MSR-TR-2023-19) (Koka book). It targets the standard memory-management dilemma directly: manual management gives “the best performance but at a significant programming burden,” while garbage collection means “a runtime system and pay a price in performance, memory usage, and unpredictable latencies” (Koka book). Koka “distinguishes itself through effect typing, effect handlers, and Perceus memory management” (Koka book).
  • Most distinctive idea: Whole-program effect inference — “Koka infers and tracks the effect of every function in its type” and “automatically infers all the side effects that occur in a function,” giving “deep safety guarantees backed by well-studied category theory” (Koka book). Effects tracked include exceptions, divergence, console, non-determinism, mutability, I/O and user-defined control effects (Koka book).
  • Maturity:
    • Release stage: pre-1.0 research language, actively released. Latest published release v3.2.3, published 2026-03-18 (koka-lang/koka releases).
    • Activity in 2026: active, moderately paced — repository last pushed 2026-08-15 with the most recent dev-branch commit 2026-08-15, 4,058 stars (koka-lang/koka).
  • Relevance to AI-agent-written code: Koka is close to an ideal target for auditing agent output, because effects are not merely documented but inferred into the type: if a generated function touches I/O or mutates state, that fact appears in its signature whether or not the agent intended it. A reviewer or a policy checker can therefore reject generated code that acquired an unexpected effect without reading the body. Perceus reference counting also removes GC-pause reasoning from the agent’s plate while keeping deterministic deallocation. Against this, row-polymorphic effect types are unusual enough that agents frequently produce plausible-but-ill-typed effect rows.

Austral

  • Website / repo: austral-lang.org, github.com/austral/austral
  • Summary: Austral is a “Systems language with linear types and capability-based security” (austral/austral). Its author frames linearity as the mechanism for safe manual memory: “Linear types let us have manual memory management, without runtime overhead, and without security vulnerabilities: they prevent memory leaks, use-after-free, and double-free errors” (Introducing Austral). The idea generalizes past memory: “This extends beyond memory to anything that has a lifecycle… File handles, network sockets, database handles, locks and mutexes: the correct usage of these objects can be enforced at compile time” (Introducing Austral). It also targets supply-chain risk — “an attacker adds malware to a single library used transitively by millions of computers” — with the position that “to access the filesystem, or the network, or other privileged resources, libraries should require permission to do so,” and “Austral’s solution is capability-based security” (Introducing Austral). The project is developed by an individual (GitHub user eudoxia0) rather than an organization (austral/austral releases).
  • Most distinctive idea: Linear types plus capability-based security in one systems language, so that both resource lifecycles and module permissions are compile-time facts; a design goal is explicitly to eliminate ambiguity, since “language lawyering is a design flaw: if two people can look at the same basic program and disagree about its behaviour, that’s” a defect (Introducing Austral).
  • Maturity:
    • Release stage: pre-1.0, feature-complete core. Latest release v0.2.0, published 2023-06-27; the 0.1.0 release is titled “Core language complete,” and 0.2.0 realigned borrow syntax with the rest of the language (austral/austral releases).
    • Activity in 2026: dormant — no 2026 activity; the repository was last pushed 2025-07-28 and the most recent commit is 2025-07-28, 1,573 stars (austral/austral).
  • Relevance to AI-agent-written code: Austral is unusually well matched to constraining generated code, and its author noticed this early — the introduction post records plans to “use OpenAI’s finetuning API to teach a code completion model to write Austral for me” and reports “promising results teaching Austral to ChatGPT interactively” (Introducing Austral). Capabilities mean a generated module physically cannot open a socket unless it was handed that permission, which is a far stronger containment story than sandboxing generated code after the fact. Linearity turns forgotten close() calls — a classic LLM omission — into compile errors. The practical obstacle is that the project is dormant, so there is neither a maintained toolchain nor a growing corpus.

Inko

  • Website / repo: inko-lang.org, github.com/inko-lang/inko
  • Summary: Inko is “a programming language for building concurrent software, but without the usual headaches such as data race conditions and non-deterministic garbage collectors” (Inko 0.19.1 release notes). It “features deterministic automatic memory management” and “compiles to machine code using LLVM” for Linux, macOS and FreeBSD (Inko 0.19.1 release notes). Memory is managed by single ownership: “Single ownership is a way of managing memory by assigning owners to values, and discarding… of these values when the owner is done with them,” which means memory management “is deterministic and predictable, and doesn’t require a garbage collector or (atomic) reference counting” (Inko 0.10.0 release notes). Concurrency is Erlang-derived: “Inspired by Erlang, Inko uses lightweight isolated threads known as ‘lightweight processes’. These processes don’t share memory and communicate by sending messages” (Inko 0.10.0 release notes). Development is self-funded rather than corporate (Inko 0.19.1 release notes).
  • Most distinctive idea: Single ownership combined with isolated message-passing processes, but with an aliasing rule deliberately looser than Rust’s: “Unlike Rust, Inko allows you to have both mutable and immutable references to the same value at the same time” (Inko 0.10.0 release notes); values sent between processes are moved, “no longer available to the sender” (Inko 0.10.0 release notes).
  • Maturity:
    • Release stage: pre-1.0 alpha/beta. Version 0.10.0 (2022) was the major redesign — released after “almost two years since the last Inko release” and “1.5 years since we started work on drastically changing Inko”; the project states “Inko is only at version 0.10, and we still have a long road ahead of us before reaching version 1.0” and warns of “bugs, compiler crashes, performance issues, or missing/lacking documentation” (Inko 0.10.0 release notes). Version 0.19.1 is documented on the site (Inko 0.19.1 release notes); no GitHub Releases entries are published for the repository (inko-lang/inko).
    • Activity in 2026: active — repository last pushed 2026-09-11, most recent commit 2026-09-05, 1,302 stars (inko-lang/inko).
  • Relevance to AI-agent-written code: Isolated processes with move-on-send semantics remove most of the concurrency reasoning an agent would otherwise have to do by hand: there is no shared mutable state to protect, so no lock ordering to get wrong. Deterministic, GC-free memory management also makes generated code’s resource behavior predictable enough to test. The looser aliasing rule than Rust’s is a mixed blessing — it makes generated code compile more often, but it means some correctness reasoning the Rust borrow checker would perform has to happen elsewhere. Its pre-1.0 status and small corpus remain the practical limit.

Gleam

  • Website / repo: gleam.run, github.com/gleam-lang/gleam
  • Summary: Gleam is a friendly, statically typed language that runs “on the Erlang virtual machine” and can also target “JavaScript runtimes,” with “a type system inspired by languages such as Elm, OCaml, and Rust” (Gleam version 1). Its stated goal is to make software development and maintenance “as predictable, stress-free, and enjoyable as possible,” optimizing for reading and debugging rather than writing: “Reading and debugging code is more difficult than writing new code, so we optimise for this” (Gleam version 1). It is explicitly not a big-tech project — “Gleam is not a project from Microsoft or Google, it’s a community project” — with “one full-time developer working on Gleam… and a number of part time volunteers,” funded via GitHub Sponsors, of which “the largest contributor is Fly.io, who provide approximately half the funding” (Gleam version 1).
  • Most distinctive idea: Enforced minimalism as a language-design commitment — “a strong desire to have only one way of doing things,” with the explicit statement that “Simplicity is a feature in Gleam and that will not change going forward” (Gleam version 1), and the consequence that “with Gleam refactoring is low risk and low stress” (Gleam version 1).
  • Maturity:
    • Release stage: 1.0+ / stable. “Today Gleam v1.0.0 has been released!… This is the first ‘stable’ release of the language” (Gleam version 1), dated 04 March, 2024 (Gleam news index). The most recent minor release listed is v1.18.0 on 29 July, 2026 (Gleam news index), with v1.18.1 published 2026-08-01 (gleam-lang/gleam releases).
    • Activity in 2026: very active — repository last pushed 2026-09-10, most recent commit 2026-09-10, 21,904 stars (gleam-lang/gleam).
  • Relevance to AI-agent-written code: “Only one way of doing things” is arguably the single most agent-friendly property a language can have: a small regular grammar with no competing idioms narrows the space in which a model can hallucinate, and reduces the variance between what the agent writes and what a reviewer expects. Full static typing over the BEAM means generated concurrent code gets checked rather than merely hoped for. The main cost is ecosystem depth relative to Elixir or TypeScript, so agents will more often need to write library code from scratch instead of calling something existing.

Unison

  • Website / repo: unison-lang.org, github.com/unisonweb/unison
  • Summary: Unison is a statically typed functional language whose codebase is a database of content-addressed definitions rather than a directory of text files (The big idea). Every definition has “a unique and deterministic address (its hash) in this vast immutable address space. Names are like pointers to addresses in this space,” and “Names are just separately stored metadata that don’t affect the function’s hash” (The big idea). This targets distributed programming, which today requires “many separate programs stitched together with a morass of glue, duct tape, YAML files, and blobs of JSON being sent over the network” (The big idea). Consequences claimed include that “dependency conflicts and the diamond dependency problem are just not a thing,” that “arbitrary computations [can] just be moved from one location to another, with missing dependencies deployed on the fly,” and that “a Unison codebase is never in a broken state, even midway through a refactoring” (The big idea).
  • Most distinctive idea: Content-addressed code: “Definitions never change” and “the hash of increment uniquely identifies its exact implementation and pins down all its dependencies” (The big idea), which is what makes instant non-breaking renames, type-based search and hyperlinked code possible (The big idea).
  • Maturity:
    • Release stage: 1.0+. “After years of engineering, design, and community collaboration, we’re excited to release Unison 1.0. This version delivers a refined programming workflow and a mature toolchain” (Unison blog); release/1.0.0 was published 2025-11-25 and the latest release is release/1.4.0, published 2026-08-19 (unisonweb/unison releases).
    • Activity in 2026: active — repository last pushed 2026-08-19 with the most recent commit 2026-08-19, 6,725 stars (unisonweb/unison).
  • Relevance to AI-agent-written code: Content addressing directly removes the failure modes that dominate LLM-written code at scale: there are no stale imports, no version-resolution conflicts, and no partially-broken intermediate states during refactoring, because a definition is identified by its hash rather than by a name the agent has to remember correctly (The big idea). Type-based search gives an agent a mechanical way to find an existing function instead of inventing one. Notably, the project has begun shipping agent-facing tooling: 1.1.0 “contains new MCP tools” and 1.0.2 improved “the MCP AI agent commands” (Unison blog). The offsetting cost is that the codebase-as-database model is unlike anything in training corpora, so agents must be taught the UCM workflow rather than inferring it.

Mojo

  • Website / repo: modular.com, github.com/modular/modular
  • Summary: Mojo is developed by Modular as the language layer of the Modular Platform alongside MAX (modular/modular). It was publicly introduced in a post dated September 7, 2023 titled “Mojo🔥 - It’s finally here!” (Modular blog). Modular open-sourced the standard library in 2024, after which “nearly 200 contributors landed pull requests” touching “200k+ lines of code,” with “over 1,000” more people filing issues (Mojo 1.0 is here). Modular states it uses the language itself in production: “We depend on it every day in production at Modular” (Mojo 1.0 is here). The 1.0 announcement frames August 11, 2026 as “a landmark day in the history of programming languages and AI” (Mojo 1.0 is here).
  • Most distinctive idea: n.a. — the primary pages fetched (the 1.0 forum announcement and the launch blog) do not state a single distinctive design idea; the 1.0 post explicitly covers stability commitments rather than semantics (Mojo 1.0 is here).
  • Maturity:
    • Release stage: 1.0+ / production-used. “Mojo 1.0 is out today!… 1.0 does not mean the language is finished. It means you can build on a solid foundation without constant breaking changes… We’re making that commitment now because Mojo is ready” (Mojo 1.0 is here). Mojo 1.0 shipped as part of MAX 26.5 on August 11, 2026 (Modular blog); the corresponding tag max/v26.5.0 (“MAX 26.5 / Mojo 1.0.0”) was published 2026-08-11, preceded by max/v26.4.0 (“Mojo 1.0.0b2”, 2026-06-18) and max/v26.3.0 (“Mojo 1.0.0b1”, 2026-05-07) (modular/modular releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 29,707 stars (modular/modular).
  • Relevance to AI-agent-written code: Mojo’s practical advantage for agents is familiarity plus a compiler: it is Python-shaped enough that models generate syntactically valid code on the first try, while static typing and ahead-of-time compilation catch errors that would be silent runtime failures in Python. That combination — high generation success rate and a strict rejection filter — is what agent workflows want. The risk is the inverse of the same property: because Mojo looks like Python, agents readily emit valid Python that is not valid Mojo, and the 1.x additive-change policy (Mojo 1.0 is here) will only slowly reduce that confusion.

MoonBit

  • Website / repo: moonbitlang.com, github.com/moonbitlang/core
  • Summary: MoonBit describes itself as “a programming language designed for tooling (AI focused) and user experience,” with “robust and extremely fast tooling” (MoonBit beta release). Feature-wise it positions itself against Rust: “it is very close to Rust with GC but shipped with robust and extremely fast tooling” (MoonBit beta release). It builds async and error handling into ordinary function syntax: “Async and error-aware functions are written just like regular ones—no await, no extra syntax” (MoonBit beta release). It also “treats pattern matching as a first-class feature” (MoonBit 1.0 roadmap). The developing organization is not named on the fetched official pages.
  • Most distinctive idea: Designing the language for AI tooling as a first-order requirement rather than a downstream concern — “a programming language designed for tooling (AI focused) and user experience” — paired with effect-free-looking syntax for async and checked errors, so that “async and error-aware functions are written just like regular ones” (MoonBit beta release).
  • Maturity:
    • Release stage: beta. “The Beta release marks a clear commitment: MoonBit’s core language features are now stable,” syntax “is considered stable and changes will go through RFC process,” while “the standard library and toolchain will continue to improve” and “async and checked error handling are in beta” (MoonBit beta release). “In June 2025, MoonBit released its beta version” and “We are planning to officially launch version 1.0 in the first half of 2026” (MoonBit 1.0 roadmap); as of September 2026 no 1.0 announcement was found on the official blog. Specific version-number-with-date for the current release: n.a.
    • Activity in 2026: very active — the core library repository was last pushed 2026-09-12 with the most recent commit 2026-09-12, 1,205 stars (moonbitlang/core).
  • Relevance to AI-agent-written code: MoonBit is the clearest case in this survey of a language whose stated purpose includes machine authorship (MoonBit beta release), and the design choices follow from it: fast compilation gives agents a tight generate-check loop, and eliminating await and error-propagation ceremony removes two of the most common syntactic mistakes models make in Rust and TypeScript. First-class pattern matching (MoonBit 1.0 roadmap) also pushes generated code toward total, exhaustively-checked case analysis rather than defensive if chains. The counterweight is that “close to Rust with GC” means agents will import Rust idioms (lifetimes, unsafe, trait patterns) that do not apply.

Verse

  • Website / repo: verselang.github.io/book, dev.epicgames.com Verse reference
  • Summary: “Verse is a multi-paradigm programming language developed by Epic Games” for “creating gameplay in Unreal Editor for Fortnite and building experiences in the metaverse” (Book of Verse overview). It draws “from functional, logic, and imperative traditions” and is framed as “a departure from traditional programming languages” that “carry decades of historical baggage and design compromises” (Book of Verse overview). Its design constraints come from the premise that “code runs in a single global simulation—the metaverse,” where “code lives forever in a persistent metaverse,” “millions of developers contribute to a shared codebase,” “backward compatibility is not optional but essential,” and “the boundary between compile-time and runtime is fluid” (Book of Verse overview). Epic commits to compatibility: “For Verse code that you write today, you can expect Verse to provide backward compatibility and continue to work with future updates to the language” (Verse language reference).
  • Most distinctive idea: Radical uniformity — “It’s Just Code”: “Complex concepts that might require special syntax or constructs in other languages are expressed as regular Verse code. There’s no magic—everything is built from the same primitive constructs, creating a uniform and predictable programming model” (Book of Verse overview) — in service of code that is “safe, concurrent, and composable by default” and safe to run when “untrusted” in a shared environment (Book of Verse overview).
  • Maturity:
    • Release stage: production-used, versioned by language version rather than semver. Epic documents “Verse Language Version 1 Updates and Deprecations” (Verse language reference) and states “Epic Games is continuing to develop the Verse programming language and add more features” (Verse language reference). Exact release date of Verse Version 1: n.a. The community Book of Verse states no version numbers or release dates (Book of Verse overview).
    • Activity in 2026: n.a. — Verse has no public primary repository; the compiler ships inside Unreal Editor for Fortnite, and no commit history was inspectable.
  • Relevance to AI-agent-written code: Two Verse properties matter for machine authorship. First, uniformity — no special-cased syntax, everything built from the same primitives (Book of Verse overview) — is precisely the regular-grammar property that reduces hallucination. Second, the language is designed on the assumption that untrusted code from unknown authors will run in a shared live simulation (Book of Verse overview), which is structurally the same threat model as executing agent-generated code. The hard limit is closure: with no open compiler or public repository, agents cannot be evaluated against Verse outside Epic’s tooling, and the public corpus is thin.

Bend / HVM2

  • Website / repo: github.com/HigherOrderCO/Bend, github.com/HigherOrderCO/HVM2
  • Summary: “Bend is developed by HigherOrderCO” and is “A high-level, massively parallel programming language” (HigherOrderCO/Bend). It “offers the feel and features of expressive languages like Python and Haskell,” including “fast object allocations,” “full support for higher-order functions with closures,” “unrestricted recursion” and “even continuations” (HigherOrderCO/Bend). Execution is delegated to a separate runtime: “Bend is powered by the HVM2 runtime,” described as “HOC’s massively parallel Interaction Combinator evaluator” (HigherOrderCO/Bend), itself “a massively parallel, optimal functional runtime in Rust” (HigherOrderCO/HVM2). The repository was created 2023-08-29 (HigherOrderCO/Bend).
  • Most distinctive idea: Automatic parallelism from an interaction-combinator runtime, with no concurrency constructs in the language at all: “Bend scales like CUDA, it runs on massively parallel hardware like GPUs, with nearly linear acceleration based on core count, and without explicit parallelism annotations: no thread creation, locks, mutexes, or atomics”; “If your code can run in parallel it will run in parallel,” supporting “over 10000 concurrent threads” (HigherOrderCO/Bend).
  • Maturity:
    • Release stage: alpha / experimental. The repository does not classify itself, but cautions “The current version may have lower single-core performance,” “You can expect substantial improvements in performance as we advance our code generation and optimization techniques,” and “We are still working to support Windows. Use WSL2 as an alternative solution” (HigherOrderCO/Bend). Thirty-nine tags exist but no GitHub Release is published, so no version-with-date can be confirmed: n.a. (HigherOrderCO/Bend).
    • Activity in 2026: dormant / slowing — Bend’s repository was last pushed 2026-07-07 with the most recent commit 2026-07-07 and 19,828 stars, but the HVM2 runtime it depends on was last pushed 2024-11-21 with its most recent commit 2024-08-21, 11,342 stars (HigherOrderCO/Bend, HigherOrderCO/HVM2).
  • Relevance to AI-agent-written code: Parallelism-by-default removes an entire category of reasoning from the agent: there are no threads, locks, mutexes or atomics to get wrong because none exist in the language (HigherOrderCO/Bend). An agent writes ordinary recursive functional code and the runtime extracts the parallelism, which is a much better division of labor than asking a model to place synchronization correctly. Against that, performance is not compositional in an intuitive way — the same page warns about single-core performance and immature code generation — so an agent cannot reason about the cost of what it writes, and a stalled runtime repository makes it a poor production target.

Carbon

  • Website / repo: github.com/carbon-language/carbon-lang, Carbon roadmap
  • Summary: Carbon is “fundamentally a successor language approach” to C++, aimed at “interoperability with C++ as well as large-scale adoption and migration for existing C++ codebases and developers” (carbon-language/carbon-lang). It targets the observation that “C++ remains the dominant programming language for performance-critical software” but is “struggling to improve and meet developers’ needs” due to “accumulating decades of technical debt,” and that “incrementally improving C++ is extremely difficult” given both that debt and “challenges with its evolution process” (carbon-language/carbon-lang). Its requirements are “performance matching C++,” “seamless, bidirectional interoperability with C++,” “a gentle learning curve,” “comparable expressivity” and “scalable migration” (carbon-language/carbon-lang). It avoids inheriting “the legacy of C or C++” by using a “modern generics system,” “modular code organization” and “consistent, simple syntax,” and explicitly tells developers who can use Go, Swift, Kotlin or Rust that they “should” use those instead (carbon-language/carbon-lang). The README does not name a sponsoring company (carbon-language/carbon-lang).
  • Most distinctive idea: Bidirectional C++ interoperability as the organizing constraint — a successor language designed so existing C++ codebases can be migrated incrementally, including “some source-to-source translation for idiomatic C++ code,” rather than a clean-slate replacement (carbon-language/carbon-lang).
  • Maturity:
    • Release stage: experimental; no released version. The roadmap describes “Our 0.1 milestone” as a “potential 2026 goal: ship a working 0.1 language for evaluation,” adding that “shipping 0.1 in 2026 will be a very ambitious goal and may not be possible, but the end of 2026 is now the soonest that 0.1 could realistically be ready to ship,” with 0.2 targeted 2027–2028 and “ship 1.0 language & organization” beyond 2028 (Carbon roadmap). No GitHub Release is published (carbon-language/carbon-lang). Carbon entered the survey window with its public launch as an experimental C++ successor in 2022; the repository itself was created 2020-04-27 (carbon-language/carbon-lang).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 33,890 stars (carbon-language/carbon-lang).
  • Relevance to AI-agent-written code: Carbon’s “consistent, simple syntax” and modular code organization (carbon-language/carbon-lang) are exactly the properties that make C++ hard for agents to write correctly — C++‘s ambiguity, header semantics and overload resolution are a major source of model errors. If Carbon achieves bidirectional interop, agent-driven migration of C++ codebases becomes mechanically checkable file by file rather than all-at-once. The practical problem today is that there is no shipped 0.1 (Carbon roadmap), so any agent-generated Carbon is written against a moving design with essentially no corpus.

Vale

  • Website / repo: vale.dev, github.com/ValeLang/Vale
  • Summary: Vale is a systems language whose goal is “to make Vale the best language for high-performance low-overhead use cases, such as servers, games, simulations, and systems programming” (vale.dev). It has “single ownership and move semantics without needing a borrow checker” and is “memory safe with generational references” (vale.dev). Additional planned features include “Fearless FFI,” “Higher RAII,” a “region borrow checker to eliminate memory-safety overhead,” “dependency sandboxing to keep external code from corrupting Vale memory, and mitigate supply chain attacks,” “perfect replayability to completely eliminate heisenbugs, even in the presence of multithreading,” and “seamless concurrency for parallelism without added complexity” (vale.dev). It is a volunteer/sponsor-funded project with no named organization (vale.dev).
  • Most distinctive idea: Generational references — “Vale has memory-safe single ownership without garbage collection or a borrow checker, which makes it easy to write safe, fast code” (vale.dev) — i.e. memory safety enforced by generation checks at dereference rather than by static aliasing analysis.
  • Maturity:
    • Release stage: alpha / experimental. “Vale 0.2 Release” is dated May 10, 2022 on the site (vale.dev); v0.2.0 is the most recent tag on the repository and no GitHub Release is published (ValeLang/Vale).
    • Activity in 2026: dormant — no 2026 activity; the repository was last pushed 2024-05-14 with its most recent commit 2024-05-14, 2,010 stars (ValeLang/Vale).
  • Relevance to AI-agent-written code: Generational references are attractive for agent authorship because they deliver memory safety without requiring the agent to reason about lifetimes — the single largest source of failed Rust generations — while still avoiding a GC. “Perfect replayability” to “completely eliminate heisenbugs, even in the presence of multithreading” (vale.dev) would also be valuable for automated debugging loops, where an agent needs a deterministic reproduction to iterate against. In practice the project has not committed code since May 2024 (ValeLang/Vale), so these remain design claims rather than usable properties.

Flix

  • Website / repo: flix.dev, github.com/flix/flix
  • Summary: “Flix is a principled effect-oriented functional, imperative, and logic programming language developed at Aarhus University and by a community of open source contributors,” and is “actively developed by programming language researchers from Aarhus University in Denmark in collaboration with researchers from the University of Waterloo in Canada, the University of Tübingen in Germany, and the University of Copenhagen in Denmark” (flix.dev). It argues that “effect systems represent the next major evolution in statically typed programming languages,” because “by explicitly modeling side effects, effect-oriented programming enforces modularity and helps program reasoning” (flix.dev). It also embeds a logic-programming layer: fixpoint problems including “various graph reachability problems” are expressed through embedded Datalog (flix.dev). The toolchain is monolithic by design: “Flix is one self-contained tool: compiler, build tool, package manager, test runner, and REPL” (Flix get started).
  • Most distinctive idea: A total purity guarantee backed by algebraic effects: Flix “precisely tracks the purity of every expression in a program,” and “the Flix compiler provides an ironclad guarantee that if an expression is pure then it cannot have side-effects and it is referentially transparent,” with “user-defined effects and handlers” letting programmers “implement their own control structures” (flix.dev). Built-in effects come with defaults — “Fetching a URL uses the Http effect, so it appears in the signature. Each comes with a default handler” (Flix get started).
  • Maturity:
    • Release stage: pre-1.0, rapidly released research language. Latest release v0.75.3, published 2026-08-15, preceded by v0.75.2 (2026-08-07) and v0.75.1 (2026-07-09) (flix/flix releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 2,739 stars (flix/flix).
  • Relevance to AI-agent-written code: Flix’s “ironclad guarantee” that pure expressions cannot have side effects (flix.dev) turns a policy question — did the agent’s code touch the network? — into a signature check, which is exactly the auditability property agent pipelines need. Because Http and similar effects surface in signatures (Flix get started), a reviewer can gate generated code on its effect row without reading the implementation. Embedded Datalog is a further help for the class of graph/relational logic where LLMs typically write buggy imperative traversals. The friction is that effect polymorphism and Datalog-in-a-functional-language are both underrepresented in training data.

Effekt

  • Website / repo: effekt-lang.org, github.com/effekt-lang/effekt
  • Summary: Effekt is “a language with lexical effect handlers and lightweight effect polymorphism” (effekt-lang/effekt). Its premise is that “(algebraic) effect handlers let you define advanced control-flow structures like generators as user libraries” and that “those libraries can be seamlessly composed” (effekt-lang.org). It addresses two concrete failure modes of effect handlers: forgetting to handle an effect — “Effect handlers are great, but it is easy to forget handling an effect,” solved by “a static effect system that tells you where you forgot to handle something” — and the ergonomics collapse in higher-order code: “often, as soon as you start writing higher-order functions the type- and effect system starts to get in your way” (effekt-lang.org). The site frames effect operations against a familiar mechanism: “Effect handlers are exception handlers on steroids!” and “Calling an effect operation (with do yield(42)) is like throwing an exception” (effekt-lang.org). The developing organization is not named on the homepage (effekt-lang.org).
  • Most distinctive idea: “A new form of effect polymorphism, which we call contextual effect polymorphism” (effekt-lang.org), designed so that higher-order functions do not require the effect-variable plumbing that makes other effect systems unusable at scale.
  • Maturity:
    • Release stage: pre-1.0 research language, on a weekly release cadence. Latest release v0.79.0, published 2026-08-31, preceded by v0.78.0 (2026-08-24) and v0.77.0 (2026-08-17) (effekt-lang/effekt releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 467 stars (effekt-lang/effekt).
  • Relevance to AI-agent-written code: The specific problem Effekt solves — a static effect system that reports “where you forgot to handle something” (effekt-lang.org) — maps onto a real LLM failure mode, namely generating code that raises or performs an effect with no handler anywhere in the call chain. Contextual effect polymorphism matters because the alternative (explicit effect variables threaded through every higher-order signature) is verbose boilerplate that models get wrong. The limitation is scale: at 467 stars and pre-1.0, there is almost no public Effekt corpus, so agents must work from the specification rather than by imitation.

Ante

  • Website / repo: antelang.org, github.com/jfecher/ante
  • Summary: Ante is “a safe, easy systems language” (jfecher/ante) whose stated aim is to “help bridge the gap between low-level languages like C++/Rust and higher level garbage-collected languages like Java, OCaml, or Haskell” (antelang.org). It attacks shared mutability specifically: “Shared mutability is a common cause of bugs in other languages,” and Ante’s type system prevents unsafe operations on mutably shared references at compile time, with the claim that “in Ante, not only is it safe, it is zero-cost” (antelang.org). It carries an effect system with capability-like gating: “If a function does not declare it can IO, then it cannot use IO. It cannot even use external linked-in code without being allowed to do so” (antelang.org). Recent site posts are authored by Jake Fecher (2024-03-17 through 2025-10-24); no sponsoring organization is named (antelang.org).
  • Most distinctive idea: “Opt-out move semantics” — “most types are not shared and use move semantics by default,” but “shared types can be defined which enable cleaner code and a gentler learning curve” (antelang.org) — i.e. Rust-style ownership as the default with explicitly opt-in safe shared mutability rather than an escape hatch.
  • Maturity:
    • Release stage: research prototype / alpha; no published release. No GitHub Release is published for the repository, so no version-with-date can be confirmed: n.a. (jfecher/ante).
    • Activity in 2026: active — repository last pushed 2026-09-09 with the most recent commit 2026-09-09, 2,340 stars (jfecher/ante).
  • Relevance to AI-agent-written code: The can IO capability rule is directly useful for constraining generated code: a function that has not declared the capability “cannot even use external linked-in code without being allowed to do so” (antelang.org), which means an agent cannot smuggle in a shell-out or a network call without it appearing in the signature. Opt-out move semantics also raises the first-attempt compile rate relative to Rust, because the agent can reach for a shared type where lifetime gymnastics would otherwise be required, and the site notes “effects are easier to use when compared to monads” (antelang.org). With no release and no corpus, however, this is currently a design argument rather than a usable workflow.

Grain

  • Website / repo: grain-lang.org, github.com/grain-lang/grain
  • Summary: Grain is “the Grain compiler toolchain and CLI” for a language that “compiles directly to WebAssembly, taking full advantage of its speed and efficiency” (grain-lang.org, grain-lang/grain). Its motivating argument is accessibility of academic language features: many languages’ “wonderful ideas” have been “dismissed as esoteric or too difficult to learn” and have “struggled to rally a large community around them,” so “Grain is a new language that puts academic language features to work” and “aims to modernize innovative features from functional and academic programming languages and bring them to the masses” (grain-lang.org). It “has its roots in functional programming” while being “flexible enough to accommodate different programming styles for various applications” (grain-lang.org). No developing organization is named on the site (grain-lang.org).
  • Most distinctive idea: WebAssembly as the sole, first-class compilation target for a general-purpose functional language — “Grain compiles directly to WebAssembly, taking full advantage of its speed and efficiency” (grain-lang.org) — rather than Wasm as a secondary backend.
  • Maturity:
    • Release stage: pre-1.0. Latest release grain-v0.7.2, published 2026-02-08 (grain-lang/grain releases). The in-window redesign was v0.6 “Emmer,” which “features a new module system, early return, labeled + default arguments, and much more,” followed by v0.7 “Farro,” announced “with improved language and standard library ergonomics” (Grain blog).
    • Activity in 2026: active — repository last pushed 2026-09-11 with the most recent commit 2026-09-03, 3,466 stars (grain-lang/grain).
  • Relevance to AI-agent-written code: Compiling only to WebAssembly is a meaningful containment property for agent-generated code: the artifact runs in a sandbox with an explicit import surface, so a host can decide exactly which capabilities generated code receives without trusting the code itself. A small ML-family functional core with pattern matching also pushes agents toward total functions the compiler can check. The v0.6 module-system replacement (Grain blog) is a hazard in the other direction, since agents trained on pre-0.6 Grain will emit module syntax that no longer parses.

Toka

  • Website / repo: tokalang.dev, arXiv:2606.01974 (repo: tokalang/toka)
  • Summary: Toka is a systems programming language with “Explicit Resource Semantics,” presented in an arXiv experience report by Zhonghua Yi (arXiv:2606.01974). It targets the fact that “systems programming languages traditionally struggle with the tension between physical transparency and compile-time memory safety,” positioning itself between two poles: “C++ provides direct, zero-cost hardware access but lacks strict safety boundaries” while “Rust guarantees safety at the cost of complex lifetime annotations and implicit dereferencing chains” (arXiv:2606.01974). It supports “unique, shared, borrowed, and raw semantics” with a “lifetime checking mechanism” (arXiv:2606.01974). The site states that “no garbage collector, predictable resource costs, PAL static checking, and machine-readable, compiler-verifiable semantic evidence support this goal,” and that “resource and representation costs are intended to stay visible and predictable rather than being hidden behind a default runtime layer” (tokalang.dev). Semantics kept explicit and inspectable include ownership transfer, mutation, rebinding, nullability, error propagation, async suspension, FFI boundaries and representation-level access (tokalang.dev).
  • Most distinctive idea: “Handle-Soul Duality (informally referred to as the Hat-Soul model), which cleanly dissociates pointer identities (Handles) from their underlying values (Souls) at the syntactic level”; “by enforcing that bare identifiers always represent values (Souls) and explicit sigils represent pointer handles, Toka eliminates the semantic ambiguity between rebind operations and value mutations” (arXiv:2606.01974).
  • Maturity:
    • Release stage: research prototype. The paper describes “its implementation of a prototype compiler” and is titled “A Design and Implementation Experience Report on Explicit Resource Semantics”; no alpha/beta/1.0 designation is given (arXiv:2606.01974). Paper v1 submitted 2026-06-01 (arXiv:2606.01974).
    • Activity in 2026: active — the tokalang/toka repository was created 2025-12-27 and last pushed 2026-09-05 (tokalang/toka).
  • Relevance to AI-agent-written code: Toka is one of only two languages in this survey that names AI tooling in its design rationale: “the compiler exposes machine-readable semantic facts so editors and AI tools can inspect the same boundaries that developers review” (tokalang.dev). That is a concrete answer to the verification problem for generated code — instead of an agent asserting that its code does not mutate shared state, the compiler emits verifiable evidence of that. The Handle/Soul syntactic split (arXiv:2606.01974) also removes an ambiguity that models routinely get wrong in C++ and Rust, namely whether an assignment rebinds a pointer or mutates a pointee. Being a 2026 prototype with no corpus, it currently depends on grammar-constrained generation rather than imitation.

Pel

  • Website / repo: arXiv:2505.13453 — no separate official site found
  • Summary: Pel is “A Programming Language for Orchestrating AI Agents” by Behnam Mohammadi (arXiv:2505.13453). It targets the problem of “controlling and orchestrating [LLMs’] capabilities beyond simple text generation,” arguing that existing approaches — “function/tool calling and direct code generation” — are limited in “expressiveness, scalability, cost, security” and in “the ability to enforce fine-grained control” (arXiv:2505.13453). It is “inspired by the strengths of Lisp, Elixir, Gleam, and Haskell” and aims to provide “a syntactically simple, homoiconic, and semantically rich platform for LLMs to express complex actions, control flow, and inter-agent communication safely and efficiently” (arXiv:2505.13453). Features include “a powerful piping mechanism for linear composition,” “first-class closures enabling easy partial application,” “built-in support for natural language conditions evaluated by LLMs,” “an advanced Read-Eval-Print-Loop (REPeL) with Common Lisp-style restarts and LLM-powered helper agents for automated error correction,” and “automatic parallelization of independent operations via static dependency analysis” (arXiv:2505.13453).
  • Most distinctive idea: Capability control implemented at the level of the grammar itself: “Pel’s design emphasizes a minimal, easily modifiable grammar suitable for constrained LLM generation, eliminating the need for complex sandboxing by enabling capability control at the syntax level” (arXiv:2505.13453).
  • Maturity:
    • Release stage: research prototype / paper. The abstract page does not state a maturity stage or software version (arXiv:2505.13453). Paper v1 submitted 2025-04-03, last revised 2025-06-09 (v2) (arXiv:2505.13453).
    • Activity in 2026: n.a. — no public primary repository was located for this language during this research; the only related GitHub result found was an unrelated project of the same name.
  • Relevance to AI-agent-written code: Pel is the one entry in this survey designed from the ground up for machine authorship rather than merely being amenable to it. Making the grammar small and modifiable so it can drive constrained decoding means invalid programs are unrepresentable at generation time rather than rejected after the fact, and enforcing capabilities syntactically means the interpreter needs no external sandbox to bound what generated code can reach (arXiv:2505.13453). Automatic parallelization via static dependency analysis and LLM-assisted restarts in the REPL both target agent-specific workflows rather than human ones (arXiv:2505.13453). The obvious caveat is that no maintained public implementation was found, so this is an architecture proposal, not deployable tooling.

Cangjie

  • Website / repo: JCST: An Overview of Cangjie, Cangjie (Wikipedia)
  • Summary: “Cangjie is a modern programming language built at Huawei for application-level software development,” “introduced mainly for mobile application development for the HarmonyOS Next operating system” but “as a general-purpose language… also applicable to other scenarios” (JCST overview). The paper is explicit about its purpose: “instead of being an academic practice to implement novel language features, Cangjie is designed to promote the ecosystem of HarmonyOS Next” (JCST overview). Authors are affiliated with Huawei’s Programming Languages Lab, Central Software Institute, and the State Key Laboratory of Novel Software Technology at Nanjing University; Xin-Yu Feng is “a chief scientist on programming languages in Huawei” (JCST overview). Development “was started in 2019, by Xinyu Feng,” with assistance from Tianjin University and Beihang University (Cangjie (Wikipedia)).
  • Most distinctive idea: A language-specific high-level IR that keeps program structure intact for semantics-aware optimization: “The compiler frontend introduces a language-specific high-level intermediate representation, CHIR. Unlike flat low-level intermediate representations (IRs), CHIR preserves high-level program structures (such as nested control flow and class hierarchies), enabling precise, semantics-aware optimizations like devirtualization and bounds-check elimination before lowering to LLVM IR” (JCST overview). Cangjie also “features an embedded AgentDSL programming framework, natural language & programming language organic integration” (Cangjie (Wikipedia)).
  • Maturity:
    • Release stage: 1.0+ / production-used. “It was first released on June 21, 2024, as part of developer beta recruitment, for HarmonyOS NEXT app development on the preview version of the HarmonyOS operating system,” as “Cangjie 1.0 Beta”; “Cangjie was open-sourced on July 30, 2025”; stable release 1.1.3, May 29, 2026 (Cangjie (Wikipedia)).
    • Activity in 2026: n.a. — Cangjie’s source is not hosted on GitHub and no primary repository commit history was inspected during this research.
  • Relevance to AI-agent-written code: The embedded “AgentDSL programming framework” and “natural language & programming language organic integration” (Cangjie (Wikipedia)) put agent orchestration inside the language rather than in a library, which is the same bet Pel makes but backed by a shipping platform vendor. CHIR’s preservation of high-level structure (JCST overview) is mostly a compiler-performance property rather than a correctness aid for agents, though structure-preserving IRs do make automated program analysis of generated code easier. The practical constraints are corpus and access: documentation and community material are predominantly Chinese-language and HarmonyOS-scoped.

Pkl

  • Website / repo: pkl-lang.org, github.com/apple/pkl
  • Summary: Pkl is “a configuration as code language with rich validation and tooling,” released under Apple’s GitHub organization (apple/pkl README, apple/pkl). It is included here rather than treated as a data format because its maintainers position it as a language with a type system, validation and a full toolchain, not as a serialization syntax (apple/pkl README). Its window entry is unambiguous: the repository was created 2024-01-19 (apple/pkl). The README does not state a design lineage or influences (apple/pkl README).
  • Most distinctive idea: Rich validation as a language-level feature of configuration — “a configuration as code language with rich validation and tooling” (apple/pkl README) — i.e. configuration is typechecked and constrained by the language rather than validated by an external schema after generation. The README does not elaborate a single distinctive semantic mechanism beyond this (apple/pkl README).
  • Maturity:
    • Release stage: pre-1.0 but widely used. Latest release 0.32.1, published 2026-07-23 (apple/pkl releases). The README does not state a maturity designation (apple/pkl README).
    • Activity in 2026: active — repository last pushed 2026-09-11 with the most recent commit 2026-09-11, 11,518 stars (apple/pkl).
  • Relevance to AI-agent-written code: Configuration is where agent-generated output causes the most operational damage — a wrong YAML field is silently accepted and fails in production — and Pkl’s premise is that this class of error should be a type error instead (apple/pkl README). An agent generating Pkl gets rejected at evaluation time for a misspelled key or an out-of-range value, whereas the same mistake in YAML or JSON survives to deploy. Because Pkl renders to YAML/JSON, this validation can be inserted in front of existing infrastructure without changing consumers. The trade-off is a nonstandard syntax with a smaller corpus than YAML, so generation accuracy is lower on the first attempt.

Lean 4

  • Website / repo: lean-lang.org, github.com/leanprover/lean4
  • Summary: Lean 4 is the “Lean 4 programming language and theorem prover” (leanprover/lean4). Its in-window qualification is the Lean 3 → Lean 4 transition itself: the official release notes show milestone builds 4.0.0-m3 (2022-01-31), 4.0.0-m4 (2022-03-27) and 4.0.0-m5 (2022-08-22), culminating in the stable Lean 4.0.0 on 2023-09-08 (Lean release notes). Lean 4 was a complete reimplementation with a new metaprogramming and elaboration architecture, and the release notes page carries a standing warning that upgrades are semantically consequential: “When updating to a new version, please read the corresponding release notes. They may contain advice that will help you understand the differences with the previous version and upgrade your projects” (Lean release notes). Neither the release notes page nor the repository page names the developing organization in prose (Lean release notes, leanprover/lean4).
  • Most distinctive idea: Being simultaneously a dependently typed proof assistant and a general-purpose programming language in which its own tooling and metaprograms are written — “Lean 4 programming language and theorem prover” (leanprover/lean4). The fetched release-notes page does not itself state a distinctive design idea (Lean release notes).
  • Maturity:
    • Release stage: 1.0+ / production-used, on a monthly cadence. Recent releases: 4.33.1 (2026-08-21), 4.33.0 (2026-08-10), 4.32.2 (2026-07-28), with 4.34.0-rc2 also dated 2026-08-21 (Lean release notes); v4.33.1 published 2026-08-21 on the repository (leanprover/lean4 releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 9,144 stars (leanprover/lean4).
  • Relevance to AI-agent-written code: Lean 4 offers the strongest static guarantee available to an agent: a proof either typechecks or it does not, and the kernel is the arbiter. That makes it uniquely well suited to generate-and-verify loops, because the reward signal is exact rather than heuristic — unlike unit tests, a Lean proof cannot pass for the wrong reason. Dependent types also mean specifications are machine-checked artifacts, so an agent can be asked for a proof obligation rather than a plausible-looking function. The cost is difficulty: Lean’s elaborator, tactic language and monthly-changing standard library make it one of the hardest targets for a model to produce compiling output for, and version churn (Lean release notes) breaks generated proofs frequently.

Idris 2

  • Website / repo: idris-lang.org, github.com/idris-lang/Idris2
  • Summary: Idris 2 is “a purely functional programming language with first class types,” associated with Edwin Brady, who gave the talks “What’s New in Idris 2” and “The implementation of Idris 2” (idris-lang/Idris2). The repository lists 215 contributors and does not name a sponsoring organization (idris-lang/Idris2). It remains explicitly incomplete as a proof system: known gaps include “cumulativity (currently Type : Type. Bear that in mind when you think you’ve proved something)” and that “rewrite doesn’t yet work on dependent types” (idris-lang/Idris2). Note that the Idris 1 → Idris 2 redesign (a rewrite onto quantitative type theory) predates this survey window; Idris 2 is included on the basis of its in-window major releases, and readers should treat its window fit as weaker than the other entries.
  • Most distinctive idea: “First class types” (idris-lang/Idris2) — full dependent types in a general-purpose, eagerly evaluated functional language, so types can be computed and manipulated as ordinary values.
  • Maturity:
    • Release stage: pre-1.0. The repository’s “Latest” release displayed is “0.7.0 (2023 release),” dated Dec 22, 2023 (idris-lang/Idris2); the most recent published release is v0.8.0, published 2025-10-31 (idris-lang/Idris2 releases). No explicit maturity designation is stated (idris-lang/Idris2).
    • Activity in 2026: active — repository last pushed 2026-09-08 with the most recent commit 2026-09-08, 3,062 stars (idris-lang/Idris2).
  • Relevance to AI-agent-written code: Dependent types let a specification be encoded in the type so that a generated implementation cannot typecheck unless it satisfies the spec — the ideal compiler-rejects-bad-agent-output property. Idris 2’s quantitative type theory additionally tracks erasure and usage, which constrains generated code’s resource behavior, not just its shape. The practical caveats are that Idris 2 is pre-1.0 with a small corpus, and that its documented soundness gap — Type : Type and the warning to “bear that in mind when you think you’ve proved something” (idris-lang/Idris2) — means a typechecked Idris 2 program is not the ironclad artifact a Lean proof is.

Rocq (formerly Coq)

  • Website / repo: rocq-prover.org, github.com/rocq-prover/rocq
  • Summary: “The Rocq Prover is an interactive theorem prover, or proof assistant. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs” (rocq-prover/rocq). Its in-window event is a rename plus major version: “The Rocq Prover version 9.0, released on March 12th, 2025. This is the first release of The Rocq Prover, version 9,” which “marks the completion of the renaming from The Coq Proof Assistant to The Rocq Prover” (Rocq 9.0.0 release notes). The 9.0 notes list type-system work — “improvements to template and sort polymorphism” — and a compatibility layer of “compatibility Coq binaries and packages” (Rocq 9.0.0 release notes). Development is community/Inria-lineage; the release page states only that “the official development repo is hosted on GitHub” (Rocq 9.0.0 release notes).
  • Most distinctive idea: n.a. — neither the 9.0 release notes nor the repository page states a single distinctive design idea; the repository describes the general capability of machine-checked semi-interactive proof development (rocq-prover/rocq, Rocq 9.0.0 release notes).
  • Maturity:
    • Release stage: production-used, 9.x. Version 9.0 released March 12, 2025 (Rocq 9.0.0 release notes); latest published release V9.2.0, published 2026-03-27 (rocq-prover/rocq releases).
    • Activity in 2026: very active — repository last pushed 2026-09-11 with the most recent commit 2026-09-11, 5,571 stars (rocq-prover/rocq).
  • Relevance to AI-agent-written code: Like Lean, Rocq gives an agent a kernel-checked pass/fail signal, which is the strongest possible filter on generated output and makes it viable for autonomous verification loops. Unlike Lean, its very large existing library and decades of published developments give a model far more idiomatic material to imitate. The rename is a concrete hazard for agents, though: models trained mostly on pre-2025 material will emit coq-era package names, binaries and documentation references, and the existence of “compatibility Coq binaries and packages” (Rocq 9.0.0 release notes) means the wrong names sometimes half-work, producing confusing failures.

Swift 6

  • Website / repo: swift.org, github.com/swiftlang/swift
  • Summary: Swift 6 is a major version whose headline change reshapes the concurrency model: “Swift 6 now includes a new, opt-in language mode that extends Swift’s safety guarantees to prevent data races in concurrent code by diagnosing potential data races in your code as compiler errors” (Announcing Swift 6). It also generalizes the error type system — “Swift 6 enables functions to specify the type of error that they throw as part of their signature,” where “a function that is specified as throws… is equivalent to one that specifies throws(any Error), whereas a non-throwing function is equivalent to one that specifies throws(Never)” (Announcing Swift 6) — and extends the ownership model into generics: “Swift 6 now supports these [non-copyable] types with the generics system, making it possible to write generic code that works with both copyable and non-copyable types” (Announcing Swift 6). Pattern matching gained ownership awareness: “switch statements can now be written to avoid copying within enum pattern-matching operations,” so they “can be used with non-copyable payloads” (Announcing Swift 6). C++ interop expanded “to C++ move-only types, virtual methods, default arguments, and more standard library types including std::map and std::optional” (Announcing Swift 6).
  • Most distinctive idea: Compile-time data-race elimination as an opt-in language mode — statically diagnosing “potential data races in your code as compiler errors” (Announcing Swift 6) — combined with typed throws that unify throwing and non-throwing functions under one signature form (Announcing Swift 6).
  • Maturity:
    • Release stage: production-used. “We’re delighted to announce the general availability of Swift 6” (Announcing Swift 6); exact Swift 6.0 release date is not stated on that page: n.a. The latest published release is swift-6.3.3-RELEASE, published 2026-06-30 (swiftlang/swift releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 70,343 stars (swiftlang/swift).
  • Relevance to AI-agent-written code: Data races are the single hardest class of bug for an agent to avoid, because they are invisible in the local text and only manifest under scheduling; turning them into compiler errors (Announcing Swift 6) converts an untestable property into a mechanical one. Typed throws also make an agent’s error handling auditable, since the set of possible failures is in the signature rather than discovered at runtime. The countervailing factor is that strict concurrency checking is famously hard to satisfy: agents frequently produce code that is semantically reasonable but rejected under the Swift 6 language mode, and Swift’s large surface area and rapid evolution mean model output often reflects Swift 5 idioms.

Kotlin 2.0

  • Website / repo: kotlinlang.org, github.com/JetBrains/kotlin
  • Summary: Kotlin 2.0.0, released May 21, 2024, made the rewritten compiler the default: “In Kotlin 2.0.0, the new Kotlin K2 compiler is used by default and it is Stable for all target platforms: JVM, Native, Wasm, and JS” (What’s new in Kotlin 2.0.0). This is a type-system-visible change, not just a performance one: “The Kotlin K2 compiler now performs smart casts in even more scenarios than before,” across “local variables and further scopes,” “type checks with logical or operator,” “inline functions,” “properties with function types,” “exception handling,” and “increment and decrement operators” (What’s new in Kotlin 2.0.0). Specific semantic shifts include that with || “a smart cast is made to their closest common supertype. Before this change, a smart cast was always made to the Any type,” that “inline functions are now treated as having an implicit callsInPlace contract,” and that smart-cast information now flows into catch and finally blocks (What’s new in Kotlin 2.0.0). Multiplatform compilation was also restructured: “our implementation of the new Kotlin K2 compiler included a redesign of the compilation scheme to ensure strict separation between common and platform source sets,” so “common code doesn’t have access to platform code” (What’s new in Kotlin 2.0.0). The language is developed by JetBrains (JetBrains/kotlin).
  • Most distinctive idea: Flow-sensitive smart casting as a core ergonomic — the K2 compiler’s expanded smart-cast analysis eliminates explicit casts in cases where the type is already established by control flow, including across or checks, inline function bodies, and exception handlers (What’s new in Kotlin 2.0.0).
  • Maturity:
  • Relevance to AI-agent-written code: Smart casts help agents in a specific way: they let generated code read like the natural-language description of the logic, without the redundant cast expressions that models frequently place incorrectly. Strict separation of common and platform source sets (What’s new in Kotlin 2.0.0) is likewise useful, since it turns a common agent error — calling a platform API from shared multiplatform code — into a compile error instead of a link failure. The offsetting risk is that flow-sensitive typing makes it harder to predict from a snippet whether code will compile, and the 2.0 smart-cast changes mean identical source can typecheck differently across Kotlin versions.

Dart 3

  • Website / repo: dart.dev, github.com/dart-lang/sdk
  • Summary: Dart 3 was announced May 10, 2023 at Google I/O, “available today in both the stand-alone Dart SDK and in the Flutter 3.10 SDK” (Announcing Dart 3). Its defining change is the completion of the null-safety migration: “Now with Dart 3, it is a 100% sound null safe language!”, giving “a sound type system” in which “you can trust that if a type says a value isn’t null, then it never can be null” (Announcing Dart 3). This was breaking: “Some legacy core library APIs have been removed… and some tools have been adjusted” (Announcing Dart 3). Dart 3 also added records and pattern matching, and began a new compilation target: “We’re excited to announce the first preview of Dart to Wasm compilation today!… It’s still early, and we have lots of work to complete” (Announcing Dart 3). The announcement was published from Google I/O 2023 by a “Product Manager working on Dart and Flutter,” though it does not itself state that Google develops Dart (Announcing Dart 3).
  • Most distinctive idea: Sound null safety — not merely nullable-type annotations but a soundness guarantee the compiler and runtime can both rely on: “with 100% null safety in Dart, we have a sound type system” (Announcing Dart 3).
  • Maturity:
    • Release stage: production-used. Dart 3 released May 10, 2023 (Announcing Dart 3). No GitHub Release is published on the SDK repository, so a latest-version-with-date from the repo is n.a. (dart-lang/sdk).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 11,278 stars (dart-lang/sdk).
  • Relevance to AI-agent-written code: Null dereferences are among the most common defects in LLM-written code, and a sound null-safe type system removes the entire class at compile time rather than mitigating it with defensive checks (Announcing Dart 3). Records and pattern matching push generated code toward exhaustive case analysis the compiler can verify. Because Dart’s syntax is conventional and its corpus large, agents also achieve high first-attempt compile rates. The hazard is version confusion: pre-Dart-3 Dart with unsound nullability is heavily represented in training data, so agents emit code that would have compiled in Dart 2 but is now rejected.

Nim 2

  • Website / repo: nim-lang.org, github.com/nim-lang/Nim
  • Summary: Nim 2.0 was released 01 August 2023, “bringing ORC memory management as a default” (Nim v2.0 released). Nim is “a statically typed compiled systems programming language” that “combines successful concepts from mature languages like Python, Ada and Modula,” with a design focus on “efficiency, expressiveness, and elegance (in that order of priority)” (nim-lang/Nim). Version 2.0 changed semantics broadly: “tuple unpacking for variables is now treated as syntax sugar that directly expands into multiple assignments” and “can now be nested”; “a new form of type inference called top-down inference has been implemented”; “overloadable enums are no longer experimental”; “inside an object declaration, fields can now have default values”; “--experimental:strictEffects are now always enabled,” which “require callback parameters to be annotated with effectsOf”; and the JavaScript backend “now uses BigInt for 64-bit integer types (int64 and uint64) by default” (Nim v2.0 released).
  • Most distinctive idea: ORC — deterministic, cycle-collecting reference counting made the default memory model, so Nim gets automatic memory management without a tracing GC’s unpredictable pauses (Nim v2.0 released). Nim 2.0 pairs this with an effect/tag system that can forbid effects: “tag tracking now supports the definition of forbidden tags by the .forbids pragma which can be used to disable certain effects in proc types” (Nim v2.0 released).
  • Maturity:
    • Release stage: production-used. Nim 2.0 released 01 August 2023 (Nim v2.0 released). No GitHub Release is published on the repository, so a latest-version-with-date from the repo is n.a. (nim-lang/Nim).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 18,232 stars (nim-lang/Nim).
  • Relevance to AI-agent-written code: The .forbids pragma is the most agent-relevant feature here: it lets a human specify up front that a generated procedure may not perform certain effects, and the compiler enforces it (Nim v2.0 released). Nim’s strictDefs switch, under which “it is enforced that a variable has been given a value explicitly before the variable can be used” (Nim v2.0 released), catches another routine LLM error. Working against this is Nim’s Python-like surface with very different semantics — a shape that invites models to transfer Python idioms incorrectly — plus a macro system flexible enough that generated metaprogramming is hard to review.

Zig

  • Website / repo: ziglang.org, codeberg.org/ziglang/zig (GitHub mirror: github.com/ziglang/zig)
  • Summary: Zig’s in-window qualification is 0.15, a release that “rocks the boat with tidal waves of breaking API changes” alongside “a slew of Language Changes and Standard Library cuts” (Zig 0.15.1 release notes). Two removals reshaped the language. usingnamespace was deleted: “by eliminating this feature, all identifiers can be trivially traced back to where they are imported — by humans and machines alike,” which also “makes Incremental Compilation fundamentally simpler” (Zig 0.15.1 release notes). And async was removed from the language: “it is settled that there will not be async/await keywords in the language. Instead, they will be in the Standard Library as part of the Io Interface,” with @frameSize also removed (Zig 0.15.1 release notes). Other semantic changes include standardizing “the rules around how undefined behaves in different contexts,” so that “only operators which can never trigger Illegal Behavior permit undefined as an operand,” plus typed inline-assembly clobbers and expanded @ptrCast (Zig 0.15.1 release notes). The project also relocated its source hosting: “Migrating from GitHub to Codeberg,” dated November 26, 2025 (Zig news).
  • Most distinctive idea: Aggressive subtraction — removing language features (usingnamespace, async/await) so that every identifier’s origin is statically traceable “by humans and machines alike” and concurrency lives in a library Io interface rather than in syntax (Zig 0.15.1 release notes).
  • Maturity:
    • Release stage: pre-1.0 but production-used. Latest stable 0.16.0, released 2026-04-13 (Zig downloads); the news index dates the announcement “0.16.0 Released” to April 14, 2026 (Zig news). Current master is 0.17.0-dev.2122+3e15e99e6 dated 2026-09-10 (Zig downloads).
    • Activity in 2026: active, but not on GitHub. The GitHub repository is now a stale mirror labeled “Moved to Codeberg”: last pushed 2025-11-27 with its most recent commit 2025-11-27, 43,308 stars, latest GitHub release 0.15.1 published 2025-08-29 (ziglang/zig). Live development moved to Codeberg as of November 26, 2025 (Zig news), and master builds dated 2026-09-10 confirm ongoing work (Zig downloads).
  • Relevance to AI-agent-written code: The explicit rationale for deleting usingnamespace — making every identifier traceable to its import “by humans and machines alike” (Zig 0.15.1 release notes) — is a machine-analyzability argument, and it directly reduces the ambiguity a code-generating model has to resolve. Comptime evaluation is deterministic, and no hidden control flow means generated code does what it reads like. Two things cut the other way: Zig’s per-release breaking changes make agent output version-fragile in a way few languages match, and removing async/await invalidates a large amount of pre-0.15 Zig in training corpora, so models will emit async syntax that no longer exists.

Odin

  • Website / repo: odin-lang.org, github.com/odin-lang/Odin
  • Summary: “Odin is a general-purpose programming language with distinct typing built for high performance, modern systems and data-oriented programming” (odin-lang.org). It is “designed from the bottom up for the modern computer, with built-in support for SOA data types, array programming, and other features” (odin-lang.org). It is a community project: “Odin is an open source programming language and contributions from the community are welcome!” (odin-lang.org). The site does not state a developing organization, a version number, or a release date (odin-lang.org).
  • Most distinctive idea: First-class data-oriented programming in the type system — built-in structure-of-arrays (SOA) data types and array programming as language features rather than library patterns (odin-lang.org). The site does not single out one idea as most distinctive (odin-lang.org).
  • Maturity:
    • Release stage: pre-1.0, rolling monthly dev- releases; production-used in games/graphics. Latest release dev-2026-09, published 2026-09-01, preceded by dev-2026-08 (2026-08-06) and dev-2026-07a (2026-07-10) (odin-lang/Odin releases). No semantic version or explicit maturity statement is given on the site (odin-lang.org).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-12, 11,905 stars (odin-lang/Odin).
  • Relevance to AI-agent-written code: Odin’s appeal for generation is regularity: a small, explicit, C-adjacent language with no hidden allocation, no operator overloading and no exceptions, so generated code is straightforward to review line by line. Built-in SOA types (odin-lang.org) let an agent express a data layout declaratively instead of hand-writing the parallel-array bookkeeping where models typically introduce indexing bugs. The weakness is the absence of strong static guarantees — there is no ownership or effect system to reject unsafe generated code — so correctness rests on tests and review, and the monthly rolling releases with no semantic versioning make it hard to pin what an agent is targeting.

Hare

  • Website / repo: harelang.org, git.sr.ht/~sircmpwn/hare
  • Summary: Hare is a systems language maintained by Drew DeVault, with Joe Finney added as a maintainer during the 0.26.0 cycle and Michael Neumann maintaining the DragonflyBSD subsystem (Hare 0.26.0 released). Release 0.26.0 (February 13, 2026) changed language semantics in several places: loops became expressions — “they can now be used in expressions to compute a result other than void,” where “if the loop ends via break, the value you give to the break expressions is used as the result. Otherwise, if the loop completes without producing a result, the else branch is used” (Hare 0.26.0 released). Error handling changed in a breaking way: “the old workaround of casting to void to file off the error types from the result of your operation doesn’t work anymore,” replaced by assigning “to _ instead,” which “does not raise an assertion if an error occurs like ! would” (Hare 0.26.0 released). Struct padding moved from @offset to “nameless fields using _” (Hare 0.26.0 released).
  • Most distinctive idea: Mandatory initialization as a language rule — “Hare has required all variables (locals and globals) to be initialized at the moment they are defined” — relaxed in 0.26.0 only via an explicit opt-out: variables may now be “‘initialize[d]’ to @undefined,” after which “the programmer is then responsible for ensuring that the variable is not read from until it is initialized later on” (Hare 0.26.0 released).
  • Maturity:
    • Release stage: pre-1.0. Hare 0.26.0, released February 13, 2026 (Hare 0.26.0 released). The release post does not characterize its changes as a “major version” or use the term “breaking change” (Hare 0.26.0 released).
    • Activity in 2026: active — release 0.26.0 shipped February 13, 2026 with multiple contributors and a new maintainer joining in that cycle (Hare 0.26.0 released). Commit-level activity was not inspected: Hare is hosted on SourceHut rather than GitHub, so no repository commit history was fetched — n.a.
  • Relevance to AI-agent-written code: Requiring every variable to be initialized at definition (Hare 0.26.0 released) eliminates uninitialized-read bugs, which are a real failure mode when a model writes C-style code. Loop-as-expression with an else branch also forces the agent to say what happens when a search fails, rather than falling through with an implicitly stale value. Two negatives: the language is intentionally tiny with a small public corpus, and the 0.26.0 removal of the cast-to-void error idiom (Hare 0.26.0 released) is exactly the kind of silent idiom change that makes older model output stop compiling.

Cairo

  • Website / repo: starknet.io, github.com/starkware-libs/cairo
  • Summary: “Cairo is the first Turing-complete language for creating provable programs for general computation” (starkware-libs/cairo). Its in-window redesign is the Cairo 1 / Cairo 2 line, in which programs compile to Sierra, a safe intermediate representation; releases are versioned jointly against Sierra and Starknet, e.g. Cairo v2.2.0 is “associated with Sierra v1.3.0 (same as Cairo v2.1.0)” and “compatible with Starknet ≥0.12.1 (that is, it is supported on all Starknet environments)” (Cairo v2.2.0 is out). The v2.2.0 announcement notes it carried “only high-level upgrades (i.e., no Sierra changes),” with language-level additions including a refactored derivable Hash trait, “derive default and a default impl for small tuples,” “a PartialEq implementation for arrays and spans to the corelib,” and the selector! macro (Cairo v2.2.0 is out). Some types remained provisional: ByteArray and bytes31 were “still experimental” and contracts using them “cannot yet be deployed on Starknet” (Cairo v2.2.0 is out).
  • Most distinctive idea: Compiling a general-purpose, Rust-flavored language down to provable computation — Cairo is “the first Turing-complete language for creating provable programs for general computation” (starkware-libs/cairo) — so every execution yields a STARK-verifiable trace rather than merely a result.
  • Maturity:
    • Release stage: production-used (Starknet mainnet), 2.x. Latest release v2.20.0, published 2026-07-23, with v2.19.0 on 2026-06-24 and frequent patch releases in between (starkware-libs/cairo releases).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-10, 1,906 stars (starkware-libs/cairo).
  • Relevance to AI-agent-written code: Provability is a qualitatively different guarantee from type safety: a Cairo program’s execution can be verified by a third party who does not trust the executor (starkware-libs/cairo), which is directly relevant if agents are to produce code whose results others must accept. Compiling through Sierra also means the deployable artifact is constrained by construction, limiting the damage a badly generated contract can do. The costs are that agents must reason about proof-system costs they cannot see in the source, and that the 2.x line’s steady stream of releases plus experimental types (Cairo v2.2.0 is out) makes version-correct generation difficult in a domain where mistakes are financially irreversible.

Noir

  • Website / repo: noir-lang.org, github.com/noir-lang/noir
  • Summary: “Noir is a domain specific language for zero knowledge proofs” (noir-lang/noir) and “an open-source, proving-system-agnostic language designed specifically for zk applications” (Announcing the Noir 1.0 pre-release). The 1.0 pre-release delivered “a comprehensive set of language features,” including “full support for primitive types (integers, booleans, strings),” “complex data structures including arrays, tuples, vectors (including bounded vectors), and hashmaps,” “advanced features like Options and custom structs,” and “generic type support for flexible, reusable code” (Announcing the Noir 1.0 pre-release). Adoption is real: “leading projects like zkEmail, zkPassport, zkLogin, and Aztec Network are already leveraging Noir’s capabilities” (Announcing the Noir 1.0 pre-release). The blog is published by Aztec, though the post does not explicitly identify the maintaining organization (Announcing the Noir 1.0 pre-release).
  • Most distinctive idea: Proving-system agnosticism — a zero-knowledge language whose programs are not tied to one proof backend, so the same Noir circuit can be compiled against different proving systems (Announcing the Noir 1.0 pre-release).
  • Maturity:
    • Release stage: beta. Current documented version v1.0.0-beta.26 (Noir docs), published 2026-07-30 (noir-lang/noir releases). “This pre-release marks the beginning of Noir’s journey to 1.0,” with stability and security to be ensured “through comprehensive audits before the full release” (Announcing the Noir 1.0 pre-release).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit 2026-09-11, 1,400 stars (noir-lang/noir).
  • Relevance to AI-agent-written code: Noir’s Rust-like syntax over a restricted, side-effect-free circuit semantics is a favorable combination for generation: the syntax is familiar enough for high first-attempt validity, while the domain has no I/O, no mutation of external state and no nondeterminism for an agent to reason about. The flip side is severe: circuits are constraint systems whose cost and soundness are invisible in the source, so an agent can write a Noir program that compiles, proves, and is still cryptographically wrong or ruinously expensive. Twenty-six beta iterations of a 1.0 (noir-lang/noir releases) also mean frequent breaking changes.

Sway

  • Website / repo: swaylang.org, github.com/FuelLabs/sway
  • Summary: “Sway is a domain-specific language for the FuelVM,” aimed at letting developers “write fast, safe, and efficient smart contracts with Rust-like syntax” and “purpose-built for the next generation of blockchain applications” (swaylang.org). It advertises “familiar Rust-like syntax with powerful tooling, testing, and debugging capabilities,” “compile-time memory safety checks and zero-cost abstractions,” and a “Cargo-inspired build system with dependency management and workspace support” (swaylang.org). It also ships a Solidity migration path: “built-in Charcoal integration to input Solidity code and get Sway code,” to “seamlessly migrate your Solidity contracts to Sway with our intelligent transpiler” (swaylang.org). The repository is maintained under FuelLabs and describes itself as “empowering everyone to build reliable and efficient smart contracts” (FuelLabs/sway).
  • Most distinctive idea: Rust-derived language design targeted at a purpose-built VM rather than the EVM — “Sway is a domain-specific language for the FuelVM” (swaylang.org) — with an automated Solidity-to-Sway transpiler as a first-class migration mechanism (swaylang.org).
  • Maturity:
    • Release stage: pre-1.0 but production-deployed. Latest release v0.72.1, published 2026-08-28 (FuelLabs/sway releases). Earlier release notes record the removal of testnet channels — “removes support for beta-1, beta-2, beta-3, beta-4, beta-5, and devnet channels in forc-deploy and adds a new mainnet channel” — and a “formalize code freeze” step (FuelLabs/sway releases). The site states no maturity stage (swaylang.org).
    • Activity in 2026: active — repository last pushed 2026-09-07 with the most recent commit 2026-08-28, 61,446 stars (FuelLabs/sway).
  • Relevance to AI-agent-written code: Rust-like syntax means agents generate syntactically plausible Sway with little training-specific adaptation, and compile-time memory safety checks (swaylang.org) catch a category of error before deployment. The transpiler angle is genuinely interesting for agent workflows, since translating an audited Solidity contract mechanically is safer than asking a model to rewrite it. But surface familiarity is a trap here: Sway’s semantics are FuelVM-specific, and an agent that transfers Solidity or Rust assumptions about storage, reentrancy or gas will produce code that compiles and loses money. Smart contracts are also the worst domain for unreviewed generation, since deployment is irreversible.

Leo

  • Website / repo: leo-lang.org, github.com/ProvableHQ/leo
  • Summary: Leo is “the Leo programming language: a programming language for formally verified, zero-knowledge applications” (ProvableHQ/leo), described in its docs as “an open-source, statically-typed, imperative programming language” for “building private applications on the Aleo blockchain” (Leo docs). It aims to hide cryptographic machinery from developers: “it abstracts the complexities of zero-knowledge cryptography, enabling developers to create secure, privacy-preserving applications while abstracting technical complexities” (Leo docs). Its syntax lineage is mainstream: “influenced by languages like JavaScript and Rust, Leo offers a familiar and readable syntax” (Leo docs). The docs do not name the developing organization; the repository is under the ProvableHQ organization (Leo docs, ProvableHQ/leo).
  • Most distinctive idea: Zero-knowledge circuit generation as an invisible compiler concern — abstracting “the complexities of zero-knowledge cryptography” behind an ordinary imperative, statically typed language (Leo docs) so that developers write conventional code and get privacy-preserving, formally verifiable programs out.
  • Maturity:
    • Release stage: 4.x, production-oriented. Documented version 4.4.2 (Leo docs); latest release leo-lang-v4.4.2, published 2026-08-19 (ProvableHQ/leo releases). The docs do not state an explicit maturity stage but reference an SDK to “productionize your Leo program” (Leo docs).
    • Activity in 2026: active — repository last pushed 2026-09-10 with the most recent commit 2026-09-09, 4,823 stars (ProvableHQ/leo).
  • Relevance to AI-agent-written code: A “familiar and readable syntax” drawn from JavaScript and Rust (Leo docs) means high generation fluency, and static typing plus a formal-verification orientation (ProvableHQ/leo) gives the compiler real power to reject bad output. The abstraction that helps humans hurts agents in one specific way, though: because the cryptographic cost model is hidden (Leo docs), an agent cannot see that a loop it wrote will blow up circuit size, and privacy leaks through public/private data flow are a semantic error no type checker here reports. As with all chain languages, irreversible deployment raises the bar for unreviewed generation.

Juvix

  • Website / repo: juvix.org, github.com/anoma/juvix
  • Summary: Juvix is “a language for intent-centric and declarative decentralised applications,” developed under the Anoma organization (anoma/juvix). “This repository is specifically dedicated to the compiler of the Juvix programming language” (anoma/juvix). Its topic tags position it as functional programming for arithmetic circuits and privacy-preserving technologies (anoma/juvix). The repository page does not state a design lineage or influences (anoma/juvix).
  • Most distinctive idea: Targeting intents rather than transactions — a declarative language whose programs express what an application wants rather than the imperative steps to achieve it, compiled toward arithmetic circuits for decentralised execution (anoma/juvix).
  • Maturity:
    • Release stage: pre-1.0 research language. Latest release v0.6.10, published 2025-03-26, out of 48 releases total (anoma/juvix releases, anoma/juvix). No maturity designation beyond the latest release is given (anoma/juvix).
    • Activity in 2026: dormant — no 2026 activity; the repository was last pushed 2025-11-05 with its most recent commit 2025-11-05, 509 stars (anoma/juvix).
  • Relevance to AI-agent-written code: Declarative, intent-level programming is in principle the right abstraction level for agent authorship, since stating a desired outcome is closer to what a model can do reliably than orchestrating a correct imementation sequence — and it shifts the burden of finding a valid execution onto the compiler and solver. A dependently typed functional core also gives strong compile-time rejection of nonsense. In practice the project has not committed since November 2025 (anoma/juvix) and has a negligible public corpus, so it is a design direction rather than a viable agent target today.

Wing (Winglang)

  • Website / repo: winglang.io, github.com/winglang/wing
  • Summary: “Winglang is a new open-source programming language designed for the cloud (aka ‘cloud-oriented’)” that “enables developers to build distributed systems that leverage cloud services as first-class citizens by combining infrastructure and application code in a safe and unified programming model” (winglang/wing). It targets a specific pain: “cloud applications are fundamentally different from applications that run on a single machine — they are distributed systems that rely on cloud infrastructure,” and “developing for the cloud today requires mastering various layers of the cloud stack, IAM roles, networking, and numerous tools, along with finding creative ways to test and debug code,” while “long deployment times hinder iteration cycles” (winglang/wing). “Wing is built by Elad Ben-Israel, the guy behind the AWS CDK, the gang at the Wing Cloud team and an amazing community of contributors (also known as Wingnuts)” (winglang/wing).
  • Most distinctive idea: A two-phase execution model built into the language: “preflight code is executed during compilation and produces the infrastructure configuration for your app (e.g. Terraform, CloudFormation, etc). Inflight code is compiled into JavaScript and executed within cloud compute platforms in Node.js environments” (winglang/wing) — so infrastructure and runtime logic are one typechecked program rather than two artifacts kept in sync by hand.
  • Maturity:
    • Release stage: pre-1.0. Latest release v0.85.49, published 2025-02-03, out of 2,006 releases (winglang/wing releases, winglang/wing).
    • Activity in 2026: low but nonzero — repository last pushed 2026-09-07 with the most recent commit 2026-09-07, 5,399 stars; no new release has been published since February 2025 (winglang/wing).
  • Relevance to AI-agent-written code: The preflight/inflight split is directly valuable for agents because the most common class of cloud bug an agent produces — application code that calls a resource whose IAM permission or wiring was never provisioned — becomes a compile error rather than a runtime 403 (winglang/wing). Compiling preflight code to Terraform/CloudFormation also means generated infrastructure is inspectable as a plan before anything is created, which fits human-in-the-loop review. Working against it: the language is pre-1.0 with no release in over eighteen months, and its abstraction hides provider-specific behavior that an agent nonetheless needs to reason about.

Onyx

  • Website / repo: onyxlang.io, github.com/onyx-lang/onyx
  • Summary: Onyx is “the compiler and developer toolchain for Onyx,” a language that “uses a modernized C-like syntax, similar to Jai or Odin” (onyx-lang/onyx, onyxlang.io). “Onyx is a procedural language, but does allow for functional-inspired syntax using the pipe operator” (onyxlang.io). It is community-developed with no named organization: “Onyx is an open source project so contributions from the community are welcome and encouraged!”, and “the onyx-lang/onyx GitHub repository is the official source of Onyx” (onyxlang.io). The repository was created 2022-04-04, placing its public history inside the survey window (onyx-lang/onyx). The site does not state a specific problem the language targets (onyxlang.io).
  • Most distinctive idea: A modernized C-family procedural language whose primary target is WebAssembly, with pipe-operator composition grafted onto imperative code (onyxlang.io). The site does not designate a single most distinctive idea (onyxlang.io).
  • Maturity:
    • Release stage: beta. “Beta Release 0.1.13,” dated 8th November 2024, preceded by “Beta Release 0.1.12” on 19th May 2024 (onyxlang.io); v0.1.13-beta was published 2024-11-09 (onyx-lang/onyx releases).
    • Activity in 2026: largely dormant — repository last pushed 2026-02-26 with the most recent commit 2026-02-26 and no activity in the six months since, 691 stars (onyx-lang/onyx).
  • Relevance to AI-agent-written code: A small C-like grammar is easy for a model to emit correctly, and a WebAssembly target means generated programs run in a capability-limited sandbox by default, which is a useful containment property when executing untrusted agent output. Beyond that, Onyx offers little that specifically helps machine authorship: there is no ownership model, effect system or capability discipline to reject unsafe generated code, and with 691 stars and no commits since February 2026 (onyx-lang/onyx) the corpus is far too small for reliable imitation.

Amber

  • Website / repo: amber-lang.com, github.com/amber-lang/amber
  • Summary: Amber is “the programming language compiled to Bash/Ksh/Zsh” (amber-lang/amber), presented as “a modern, type-safe programming language that catches bugs and errors at compile time” for shell scripting (amber-lang.com). It emphasizes exhaustive failure handling: “Amber ensures that you handle everything that could fail” (amber-lang.com). The site notes the project won “the best Engineering Project in Technology at Wrocław University” (amber-lang.com). The repository was created 2022-07-20, placing it in the window (amber-lang/amber). The site does not name the maintainers or a design lineage (amber-lang.com).
  • Most distinctive idea: Compiling a statically typed language down to portable shell — “a language compiled to Bash” (amber-lang.com) — so scripts get compile-time typing and mandatory error handling while still deploying as a plain shell script with no runtime dependency.
  • Maturity:
    • Release stage: alpha. The most recent published release is 0.6.0-alpha, published 2026-04-27 (amber-lang/amber); the version string itself carries the alpha designation.
    • Activity in 2026: active — repository last pushed 2026-09-10 with the most recent commit on the default branch also 2026-09-10, 5,222 stars (amber-lang/amber).
  • Relevance to AI-agent-written code: Shell is one of the most dangerous targets for generated code — unquoted expansions, silent command failures and ignored exit codes are exactly the errors a language model reproduces from its training corpus. Amber’s compile-time typing and its insistence that “you handle everything that could fail” (amber-lang.com) convert those into compiler errors, which gives an agent a verification signal that raw Bash never provides. The counterweight is corpus scarcity: models have seen enormous amounts of Bash and almost no Amber, so an agent is likely to fall back on Bash idioms that Amber rejects. For agent-authored automation the pragmatic pattern is to let the agent target Amber and treat compile failures as the review gate.

Neut

  • Website / repo: vekatze.github.io/neut, github.com/vekatze/neut
  • Summary: Neut is “a functional programming language with static memory management” (Neut overview), maintained by the developer publishing under the handle vekatze (vekatze/neut). Its goal is to obtain deterministic deallocation without either a garbage collector or a Rust-style borrow checker, by making memory behaviour follow from types: it offers “predictable, type-directed memory management” (Neut overview). The compiler “translates a type into a function for discarding and copying values of the type,” which is how it arranges that “every variable is used exactly once” without forcing the programmer to write linear code by hand (Neut overview). The type theory is stated compactly by the documentation as “The type system ≈ System Fω + ADT + recursion + box modality” (Neut overview).
  • Most distinctive idea: Compiling types themselves into discard/copy functions so that linearity is achieved by elaboration rather than by programmer annotation — “translates a type into a function for discarding and copying values of the type,” making “every variable is used exactly once” an invariant of the generated code (Neut overview). Borrowing is then recovered through a “box modality … achieving something like borrowing” (Neut overview).
  • Maturity:
    • Release stage: pre-1.0 (0.x). Most recent published release 0.18.1, published 2026-05-24 (vekatze/neut).
    • Activity in 2026: active — repository last pushed 2026-09-09 with the most recent commit on the default branch also 2026-09-09, 1,009 stars (vekatze/neut).
  • Relevance to AI-agent-written code: Neut’s approach is unusually favourable to machine authorship among no-GC languages: the programmer never writes lifetimes, borrows or linearity annotations, because the compiler derives discard and copy behaviour from the type (Neut overview). That removes the class of error that dominates AI-generated Rust while keeping deterministic deallocation, so an agent can write plainly typed functional code and still get predictable memory behaviour. Against that, the box modality is an unfamiliar construct with almost no public code corpus, and a 0.x language with a single primary maintainer offers little idiomatic material for a model to imitate.

C3

  • Website / repo: c3-lang.org, github.com/c3lang/c3c
  • Summary: C3 positions itself as a direct continuation of C rather than a replacement: “C3 is an evolution, not a revolution: The speed of C, shaped for modern software” (c3-lang.org), described on the site as “The Ergonomic, Safe and Familiar Evolution of C” (c3-lang.org). It “builds on the syntax and semantics of the C language” (c3-lang.org) and keeps binary-level compatibility, offering “full C ABI compatibility out of the box” (c3-lang.org). The reference implementation is the c3c compiler (c3lang/c3c). The official site does not name a sponsoring organization (c3-lang.org).
  • Most distinctive idea: Strict conservatism about the C surface plus zero-friction interop — C3 aims to be C with modern ergonomics while retaining “full C ABI compatibility out of the box” (c3-lang.org), so existing C code and libraries are used directly rather than through a binding layer, unlike successor languages that introduce a new object model.
  • Maturity:
    • Release stage: pre-1.0 (0.x), usable. Current version is v0.8.3, published 2026-08-12 (c3lang/c3c); the site likewise lists the current version as v0.8.3 (c3-lang.org).
    • Activity in 2026: very active — repository last pushed 2026-09-12 with the most recent commit on the default branch 2026-09-11, 5,814 stars (c3lang/c3c).
  • Relevance to AI-agent-written code: Because C3 deliberately preserves C’s syntax and semantics (c3-lang.org), an agent’s very large latent knowledge of C transfers almost directly, which is the opposite of the corpus problem facing most languages in this survey. The ergonomic additions replace the C idioms that generated code most often gets wrong, and full C ABI compatibility means an agent can call existing libraries without inventing binding code. The hindrance is that C3 does not add an ownership, effect or capability discipline, so the compiler cannot reject the memory-safety errors an agent will still produce; and 0.x status means the model’s C reflexes will occasionally produce syntax the current compiler has changed.

Jakt

  • Website / repo: n.a. (no separate official site fetched), github.com/SerenityOS/jakt
  • Summary: Jakt is “a memory-safe systems programming language” developed in the SerenityOS project’s GitHub organization (SerenityOS/jakt). Rather than emitting machine code directly, “it currently transpiles to C++” (SerenityOS/jakt), which is how it reaches an existing systems toolchain and C++ codebase. Its safety approach is a combination of strategies rather than a single discipline: automatic reference counting, strong typing, bounds checking, and “no raw pointers in safe mode” (SerenityOS/jakt). The repository is explicit about its state: “NOTE: The language is under heavy development” (SerenityOS/jakt), and parts of the design such as the safety analysis are marked “(Not yet implemented)” (SerenityOS/jakt).
  • Most distinctive idea: Achieving memory safety for a systems language by transpiling to C++ and layering automatic reference counting, bounds checking and a safe mode with “no raw pointers” on top (SerenityOS/jakt) — safety by construction over an existing C++ toolchain rather than a new backend or a borrow checker.
  • Maturity:
    • Release stage: alpha / under heavy development. “The language is under heavy development” (SerenityOS/jakt) and the repository states “No releases published,” so there is no version number to report (SerenityOS/jakt).
    • Activity in 2026: active but slowed — repository last pushed 2026-08-21 with the most recent commit on the default branch also 2026-08-21, roughly three weeks before inspection, 2,988 stars (SerenityOS/jakt).
  • Relevance to AI-agent-written code: Automatic reference counting plus bounds checking is the easiest safety model for a generator to satisfy, since it requires no lifetime reasoning at all — the agent writes ordinary object-graph code and the runtime handles reclamation. Transpiling to C++ also means generated programs are auditable as C++ by existing tooling, which is useful when a human has to review machine output. But safety analysis is still marked unimplemented (SerenityOS/jakt), so today the compiler cannot actually enforce the guarantee an agent would be relying on, and with no published releases and a small corpus, generated Jakt will frequently miss current syntax.

Motoko

  • Website / repo: docs.internetcomputer.org/motoko, github.com/caffeinelabs/motoko (the former dfinity/motoko URL now redirects here)
  • Summary: Motoko is “a high-level programming language designed for AI agents building backends for apps and services on the Internet Computer” (Motoko docs) — a positioning statement that names AI agents as the intended authors, not merely the intended users. Its execution model is actor-based and enforced by the language: “Every Motoko canister is an actor: an isolated unit of state and behavior that communicates with other actors through asynchronous messages” (Motoko docs). The language reached a stable major version in the window, with 1.0.0 recorded in the changelog on 2025-12-11 (Motoko changelog). Maintenance moved organizations during the window: the canonical repository is now caffeinelabs/motoko, described as “Simple high-level language for writing Internet Computer canisters” (caffeinelabs/motoko).
  • Most distinctive idea: Actor isolation as a non-optional language construct rather than a library — “Every Motoko canister is an actor: an isolated unit of state and behavior that communicates with other actors through asynchronous messages” (Motoko docs) — so shared mutable state across units simply cannot be expressed, and persistence of that state across upgrades is a language-level concern.
  • Maturity:
    • Release stage: 1.0+. Version 1.0.0 is recorded in the official changelog dated 2025-12-11, with 1.9.0 dated 2026-06-02 (Motoko changelog); the most recent published release on the repository is 1.16.0, published 2026-09-09 (caffeinelabs/motoko).
    • Activity in 2026: very active — repository last pushed 2026-09-12, with the 1.16.0 release cut on 2026-09-09, 590 stars (caffeinelabs/motoko).
  • Relevance to AI-agent-written code: Motoko is one of the very few languages in this survey whose maintainers explicitly frame it as a language for AI agents to write (Motoko docs), and the actor model supports that claim: because units cannot share mutable state and communicate only by asynchronous messages, an agent cannot introduce data races, and the blast radius of a wrong generated canister is bounded to that actor. Mandatory await-style asynchronous boundaries also force the concurrency structure to be visible in the source, which a reviewing agent or human can check. The friction is that upgrade-safe persistent state has non-obvious rules, which is exactly the sort of implicit constraint a generator tends to violate.

Granule

  • Website / repo: granule-project.github.io/granule.html, github.com/granule-project/granule
  • Summary: Granule is “a functional programming language based on the linear λ-calculus augmented with graded modal types” (Granule), a research language from the Granule Project aimed at making resource usage a checkable property of programs. Its stated ambition is generality over which resource is tracked: “The goal with Granule is to support arbitrary, user-customisable graded modalities to enable fine-grained, quantitative program reasoning” (Granule). The design lineage is explicitly academic, drawing on Bounded Linear Logic and “inspired by the coeffect-effect calculus of Gaboardi et al.” (Granule). The motivating applications are resource-sensitive and security-sensitive programming, including “ensuring that private data is not inadvertently leaked” (Granule), and the repository summarises it as “a statically-typed linear functional language with graded modal types for fine-grained program reasoning” (granule-project/granule).
  • Most distinctive idea: User-definable graded modalities layered on linear types, so the quantity and kind of use of every value is part of its type — “arbitrary, user-customisable graded modalities to enable fine-grained, quantitative program reasoning” (Granule) — rather than a fixed built-in notion of ownership or effect.
  • Maturity:
    • Release stage: research prototype (0.x). Most recent published release v0.9.6.0, published 2024-11-22 (granule-project/granule).
    • Activity in 2026: dormant — the most recent commit on the default branch is 2026-07-21 and the repository was last pushed 2026-07-21, with no activity in the roughly seven weeks before inspection and no release in nearly two years, 733 stars (granule-project/granule).
  • Relevance to AI-agent-written code: Graded types are the strongest specification mechanism in this survey: an agent could be asked to produce a function whose type asserts that a secret is used at most once and never leaked, and the compiler would reject a generated body that violated it (Granule). That makes Granule attractive as a target when the goal is machine-checkable guarantees about generated code rather than merely code that runs. In practice it hinders agents badly today: grade annotations are difficult to infer, the notation is unlike anything well represented in training data, and with a research-prototype implementation and no release since 2024 there is no corpus to imitate.

Rust (2024 edition)

  • Website / repo: blog.rust-lang.org, github.com/rust-lang/rust
  • Summary: Rust’s in-window change is not a new language but a new edition: the announcement of “a new version of Rust, 1.85.0,” dated 2025-02-20, states that “the Rust 2024 Edition is now stable!” (Rust 1.85.0 release notes). Editions are Rust’s mechanism for shipping semantics changes without breaking existing code: “Editions are a mechanism for opt-in changes that may otherwise pose a backwards compatibility risk” (Rust 1.85.0 release notes). This qualifies as a reshaping of surface semantics on an opt-in basis rather than a routine minor release, which is why it is included here; the ownership and borrow-checking core is unchanged. Development happens in the open in the main compiler repository, described as “Empowering everyone to build reliable and efficient software” (rust-lang/rust).
  • Most distinctive idea: The edition mechanism itself — per-crate, opt-in semantics changes that let the language reshape surface behaviour while crates on older editions keep compiling and interoperating (Rust 1.85.0 release notes). This is the structural feature that distinguishes Rust’s evolution strategy from the successor-language approach taken by Carbon or the breaking-release approach taken by Zig.
  • Maturity:
    • Release stage: 1.0+, production-used. The Rust 2024 Edition shipped stable in 1.85.0 on 2025-02-20 (Rust 1.85.0 release notes); the most recent published release at inspection is 1.98.1, published 2026-09-03 (rust-lang/rust).
    • Activity in 2026: extremely active — repository last pushed 2026-09-12 with the most recent commit on the default branch 2026-09-12, 118,434 stars (rust-lang/rust).
  • Relevance to AI-agent-written code: Rust is the interesting control case for this whole survey. Its corpus is enormous and its compiler is an exceptionally strong verifier, so an agent gets both plentiful idiomatic material and a precise rejection signal — the pattern that makes compile-error-driven agent loops work well in practice. The cost is that borrow-checker and lifetime errors are the dominant failure mode for generated Rust, which is precisely the problem Hylo, Vale, Inko and Neut each try to design away. Editions add a subtler hazard for agents: the same source can mean different things depending on the crate’s declared edition, so generated code must be matched to the target edition to compile.

TypeScript 5 / 7

  • Website / repo: devblogs.microsoft.com/typescript, github.com/microsoft/TypeScript
  • Summary: TypeScript had two in-window major versions. The first was announced as “Today we’re excited to announce the release of TypeScript 5.0!” with the stated goal of “aiming to make TypeScript smaller, simpler, and faster” (Announcing TypeScript 5.0); its notable surface changes were the standards-track decorators implementation, const type parameters, and --verbatimModuleSyntax (Announcing TypeScript 5.0). The announcement is careful to note that “TypeScript 5.0 is not a disruptive release” (Announcing TypeScript 5.0), so on its own it would be borderline for this survey. The stronger in-window event is TypeScript 7, whose latest published release at inspection is v7.0.2 on 2026-08-20 (microsoft/TypeScript) — a major version reached during the window. The exact calendar date of the 5.0 release is not stated on the announcement page, so it is recorded as n.a. here rather than guessed.
  • Most distinctive idea: Gradual structural typing layered over an existing dynamic language, evolved by explicitly non-disruptive major versions — TypeScript 5.0’s own framing is that it “is not a disruptive release” (Announcing TypeScript 5.0), a maintenance philosophy that is itself the distinguishing property relative to the clean-break languages in this survey.
  • Maturity:
    • Release stage: 1.0+, production-used. Most recent published release v7.0.2, published 2026-08-20 (microsoft/TypeScript). TypeScript 5.0 release date: n.a. (not stated on the fetched announcement page) (Announcing TypeScript 5.0).
    • Activity in 2026: extremely active — repository last pushed 2026-09-12 with the most recent commit on the default branch 2026-09-11, 111,012 stars (microsoft/TypeScript).
  • Relevance to AI-agent-written code: TypeScript is currently the most agent-friendly language in practical terms, for reasons that have nothing to do with novel semantics: an enormous training corpus, a type checker that runs in milliseconds without a link step, and structural typing that accepts approximately-shaped generated objects rather than demanding exact nominal types. That combination gives agent loops fast, informative rejection signals. The weakness is that its guarantees are erasable and unsound at the boundary — any, assertions and untyped JavaScript interop let generated code typecheck while still failing at runtime, so the checker is a weaker oracle than the ownership or effect systems elsewhere in this survey.

ReScript

  • Website / repo: n.a. (official site not fetched in this session), github.com/rescript-lang/rescript
  • Summary: ReScript is “a robustly typed language that compiles to efficient and human-readable JavaScript” (rescript-lang/rescript). Its distinguishing claim against TypeScript is soundness rather than convenience: “No any, no magic types, no surprise undefined” (rescript-lang/rescript). The project’s lineage runs through the OCaml/BuckleScript ecosystem — it was “originally created by Hongbo Zhang in 2015” and is now “maintained by the ReScript community” (rescript-lang/rescript). Its in-window event is the version 12 line: the repository shows release 12.3.0 dated 2026-05-20, with v12.3.1 published 2026-08-24 (rescript-lang/rescript).
  • Most distinctive idea: A sound, fully inferring type system with no escape hatch compiling to readable JavaScript — “No any, no magic types, no surprise undefined” (rescript-lang/rescript) — which is precisely the property TypeScript declines to provide.
  • Maturity:
    • Release stage: 1.0+, production-used. Most recent published release v12.3.1, published 2026-08-24; the repository lists 131 releases in total (rescript-lang/rescript).
    • Activity in 2026: very active — repository last pushed 2026-09-12, 7,443 stars (rescript-lang/rescript).
  • Relevance to AI-agent-written code: Removing any and implicit undefined (rescript-lang/rescript) turns the type checker into a genuine oracle: unlike TypeScript, an agent cannot silence a type error with an assertion and ship code that still breaks at runtime, so a clean compile carries much more information. Compiling to human-readable JavaScript also means a reviewer can inspect exactly what generated code will execute. The offsetting cost is corpus size — ReScript’s public code volume is orders of magnitude smaller than TypeScript’s, and its OCaml-derived syntax is far enough from JavaScript that models routinely emit invalid programs, so more compile-fix iterations are needed per accepted result.

Exclusions and judgment calls

Seed-list entry excluded

  • Bosque — excluded. The original repository microsoft/BosqueLanguage shows its most recent commit on 2022-10-27, and the successor repository referenced in community discussion, microsoft/BosqueCore, returns HTTP 404 to the GitHub API. No in-window major release or redesign could be confirmed from a primary source, and the project appears dormant or discontinued. Rather than write a section built on “n.a.” for every field, it is excluded and the reason recorded here.

All other seed-list entries — Hylo, Roc, Koka, Austral, Inko, Gleam, Unison, Mojo, MoonBit, Verse, Bend/HVM, Carbon, Vale, Flix, Effekt, Ante, Grain, Toka, Pel — are included above.

Included but dormant. These have a confirmed in-window release or redesign but are not actively developed as of September 2026, and each section flags this: Austral (last commit 2025-07-28), Vale (last commit 2024-05-14), HVM (the original HigherOrderCO/HVM repository last commit 2024-08-21; HVM2 and Bend are the live line), Juvix (last commit 2025-11-05), Granule (last commit 2026-07-21, no release since 2024-11-22), Onyx (last commit 2026-02-26).

Considered and excluded, with reasons

CandidateReason for exclusion
Scala 3Major redesign shipped in 2021, before the window opens.
Crystal1.0 landed in 2021; in-window releases (e.g. 1.21.0, 2026-07-16 per crystal-lang/crystal) are routine, not a semantics redesign.
EnsoActive in-window, but the changes inspected are platform/IDE releases rather than a language-level redesign.
BallerinaSwan Lake (2201.0.0, early 2022) is borderline in-window, but this session did not establish a single distinctive design idea from primary sources to the depth the schema requires.
V (vlang)Active repository, but no in-window major version or confirmed semantics redesign; releases in the window are 0.5.x point releases.
Cue, DhallConfiguration languages whose maintainer framing is configuration/data, not general programming. Pkl is included because Apple frames it explicitly as “a configuration as code language.”
TinyGoA compiler/toolchain for Go, not a distinct language.
Nushell and other shellsPositioned by maintainers as shells; the brief excludes shells unless framed as programming languages. Amber is included because it is framed as a language that compiles to shell.
Move, Vyper, MichelsonEither predate the window or lack a confirmable in-window major redesign; Cairo, Noir, Sway and Leo cover the smart-contract category with confirmed in-window majors.
F*, Agda, Idris 1, Eff, Frank, Links, Wyvern, Whiley, Passerine, Sixten, Lobster, Muon, Beef, Janet, Fennel, Wren, Mercury, Souffle/Ascent, Dark, WolframEither out of window, or not researched to primary-source depth in this session. Rather than pad the report with unverified entries, they are listed here as known gaps.

Known limitations of this report

  • GitHub’s HTML /commits/<branch> pages refuse automated fetching (disallow_by_robots), so per-repository commit activity was read from the GitHub REST API on 2026-09-12; the repository link in each section is the repository inspected, not a page that renders the quoted commit date.
  • Several official sites do not publish release dates or maintainer names. Those fields are written n.a. rather than filled from general knowledge. This is deliberate and affects, among others, TypeScript 5.0’s release date, Odin’s version and date on its homepage, and maintainer attribution for Amber, C3 and Odin.
  • Repository star counts and last-commit dates are point-in-time values as of 2026-09-12 and will drift.
  • The “Relevance to AI-agent-written code” sections are analysis, not sourced claims. Where they assert a fact about a language, that fact is linked; the judgments about generation and verification are the author’s.