Experimental & Cross-Host Languages — Tier 3 Index
Experimental & Cross-Host Languages — Tier 3 Index
- Type: Family index
- Family: Modern experimental systems languages + transpiled / hosted languages
- Languages catalogued: ~28
- Last updated: 2026-05-07
Family overview
This index covers two adjacent populations that share a common trait: they target a host runtime, a host language, or a future they haven’t quite reached yet.
The first population — modern experimental systems languages — comprises the post-Rust generation of pre-1.0 contenders. Each picks a different design axis to push: Carbon prioritises C++ migration, Vale and Austral push memory models (regions, capabilities), Mojo bets on Python compatibility plus MLIR, Hare bets on minimalism, Bend on implicit parallelism. Most are pre-1.0 in 2026 and most will probably stay there — the systems-programming niche is brutally competitive and Rust’s gravitational pull is strong. The interesting question is which one or two will break through, and on what dimension.
The second population — transpiled / hosted languages — compiles to a host runtime (JS, JVM, .NET, Wasm, EVM, MoveVM) rather than to native machine code. This is a strategic choice rather than a technical limitation: targeting JavaScript means instant deployment to every browser; targeting the JVM means access to the Java ecosystem; targeting Wasm means portability without a sandbox; targeting the EVM means writing Ethereum smart contracts. The languages in this group span an enormous range — CoffeeScript was a syntactic sugar, ReScript is a real ML descendant, Solidity is the dominant smart-contract language, AssemblyScript is TypeScript-flavoured AOT-to-Wasm, Dafny is verification-flavoured C#-on-.NET.
The two populations meet in blockchain languages (Move, Solidity, Vyper, Cairo, Sway) — these are simultaneously experimental (the runtimes are <10 years old) and host-targeted (they compile to a specific VM bytecode) — and in verification languages (Dafny, F*) which target a host runtime but exist primarily as research vehicles.
The state of these populations in 2026 is bifurcated. The systems-experimental group has had no breakthrough since Rust, but Mojo is growing rapidly in the AI/ML niche and Carbon has Google’s backing. The transpiled group is dominated by TypeScript (which has its own deep note — it became the JS ecosystem) and the blockchain languages (Solidity remains dominant on Ethereum; Move is the second platform thanks to Aptos and Sui). Most of the smaller transpiled-to-JS languages (CoffeeScript, LiveScript, Imba) have been steamrolled by TS+ESNext.
In our deep library
- v — V (covered deeply)
- odin — Odin (covered deeply)
- roc — Roc (covered deeply)
- gleam — Gleam (covered deeply)
- pony — Pony (covered deeply)
- typescript — TypeScript (the dominant transpiled language; covered deeply)
- rust — Rust (the gravitational pull behind every modern systems-lang attempt)
- zig — Zig (sibling to many in this list)
- ada — Ada and SPARK (the verification ancestor)
- ml-and-fp — covers Elm, PureScript, ReasonML, F*
Tier 3 — the family
Modern experimental systems languages (pre-1.0)
| Language | First release | Status 2026 | Niche | Why it matters | Source URL |
|---|---|---|---|---|---|
| Carbon | 2022 | Pre-1.0 (Google) | C++ successor with bidirectional interop | Google-backed; explicit C++-migration story | https://github.com/carbon-language/carbon-lang |
| Vale | 2020 | Pre-1.0 | Region-based memory; “single ownership without GC, without borrow checker” | Novel generational references; explores memory models past Rust | https://vale.dev/ |
| Hare | 2022 | Pre-1.0 | Minimalist systems lang | Drew Devault; “C without the worst footguns”; small spec | https://harelang.org/ |
| Jakt | 2022 | Experimental | SerenityOS systems lang (Andreas Kling) | Used to gradually replace C++ in SerenityOS | https://github.com/SerenityOS/jakt |
| Austral | 2022 | Research | Capability-based + linear types | Linear types as primary discipline; very small core | https://austral-lang.org/ |
| Mojo | 2023 | Active growth | Python-superset for AI/ML; MLIR-based | Modular Inc.; targets Python ecosystem; SIMD/GPU-first; fastest-growing in this group | https://www.modular.com/mojo |
| Wing (Winglang) | 2022 | Active | Cloud-first language | Compiles to TypeScript+Terraform; multi-cloud abstraction | https://www.winglang.io/ |
| Inko | 2015 (1.0 in 2024) | Active | Actor-based concurrent | Pony-influenced; gradual typing → static; reached 1.0 | https://inko-lang.org/ |
| Beef | 2019 | Active (game-dev) | Game-dev systems lang | Built by BeefyTech for game development; C#-flavoured but native | https://www.beeflang.org/ |
| Bend | 2024 | Pre-1.0 | Implicit parallelism via HVM | High-level lang that runs on Higher-Order Virtual Machine; auto-parallel on GPU/CPU | https://higherorderco.com/ |
| Ante | 2018 | Research | Algebraic effects + refinement types | ”Low-level lang with high-level features”; effect system | https://antelang.org/ |
| Skew | 2014 | Dormant | Small/embedded | Compiles to JS, C++, C#; mostly Evan Wallace’s research | https://skew-lang.org/ |
| Onyx | 2021 | Active (small) | Modern systems; Wasm-friendly | Used in indie game-dev community; MIT-licensed | https://onyxlang.io/ |
| Cone | 2018 | Research | Reference capabilities for memory safety | Jonathan Goodwin; explores Rust-alt memory models | https://cone.jondgoodwin.com/ |
| Lobster | 2010 | Active (small) | Game-dev experimental | Wouter van Oortmerssen (also Flatbuffers); built for game scripting | http://strlen.com/lobster/ |
Transpiled / hosted (compiles to another runtime)
| Language | First release | Status 2026 | Host target | Niche / Why it matters | Source URL |
|---|---|---|---|---|---|
| CoffeeScript | 2009 | Legacy | JavaScript | Pioneered “lang-on-JS”; killed by ES6+/TS | https://coffeescript.org/ |
| LiveScript | 2011 | Dormant | JavaScript | CoffeeScript with FP flavour; some Haskell influence | https://livescript.net/ |
| Iced CoffeeScript | 2012 | Dormant | JavaScript | Async additions to CoffeeScript before async/await landed in JS | https://maxtaco.github.io/coffee-script/ |
| ReScript (formerly BuckleScript) | 2020 (renamed) | Active | JavaScript | OCaml→JS compiler; React-friendly; strong types; used at Facebook origin | https://rescript-lang.org/ |
| Reason | 2016 | Mostly absorbed by ReScript | JavaScript / OCaml | OCaml-with-JS-syntax; original Facebook React Reason effort | https://reasonml.github.io/ |
| Imba | 2015 | Niche | JavaScript | DOM-aware web language; tag-as-syntax; small but active | https://imba.io/ |
| Stencil | 2017 | Active (Ionic) | JavaScript / Web Components | TS-flavoured compiler for Web Components; used by Ionic Framework | https://stenciljs.com/ |
| Marko | 2014 (eBay) | Active | JavaScript | eBay’s UI lang; SSR-first; competitive perf | https://markojs.com/ |
| AssemblyScript | 2017 | Active | WebAssembly | TypeScript subset → AOT Wasm; common Wasm authoring choice | https://www.assemblyscript.org/ |
| Grain | 2017 | Active (small) | WebAssembly | ML-flavoured; Wasm-native; designed for browser+server Wasm | https://grain-lang.org/ |
| Motoko | 2020 | Active | Internet Computer (DFINITY) | Actor-based; built for the IC blockchain; persistent memory model | https://internetcomputer.org/docs/current/motoko/ |
| Move | 2019 | Active | Move VM (Aptos, Sui, originally Diem) | Resource-oriented type system; #2 smart-contract platform after EVM | https://move-language.github.io/move/ |
| Solidity | 2015 | Active (dominant) | Ethereum (EVM) | The Ethereum smart-contract language; runs ~$200B+ TVL | https://soliditylang.org/ |
| Vyper | 2017 | Active | Ethereum (EVM) | Python-flavoured; security-focused; security-conscious EVM alternative | https://docs.vyperlang.org/ |
| Cairo | 2020 (StarkWare) | Active | Cairo VM (Starknet) | Zero-knowledge-proof-native; STARK-friendly | https://www.cairo-lang.org/ |
| Sway | 2022 | Active | FuelVM (Fuel blockchain) | Rust-flavoured smart-contract language for Fuel L2 | https://fuellabs.github.io/sway/ |
| Dafny | 2009 (Microsoft Research) | Active | .NET / JavaScript / Go / Python | Verification-first; compiles to multiple hosts; used at AWS, MSR | https://dafny.org/ |
| F* (FStar) | 2011 (Microsoft Research / Inria) | Active | OCaml / F# / C / Wasm | Dependently typed verification; used in HACL* (Firefox NSS, Linux kernel crypto) | https://www.fstar-lang.org/ |
| Rune | 2020 | Active (small) | Rust embedding | Rust-flavoured embeddable scripting; Lua-style use case for Rust apps | https://rune-rs.github.io/ |
Notable threads
- Why “C++ successor” is so crowded. C++ committee glacial-pace evolution + a $1T installed base + Rust’s not-quite-drop-in interop creates a market gap that everyone wants to fill. Carbon (Google), Cppfront (Herb Sutter), Circle (Sean Baxter), and many others are all variations on “give me modern type safety with C++ ABI compatibility.” None has clearly won yet; Carbon is the bet with the most institutional weight.
- Mojo is the breakout candidate of the experimental group. Modular’s Mojo achieves something rare: it is a Python superset (any Python program is a Mojo program), but adds value types, SIMD primitives, MLIR-based codegen, and GPU targeting. The AI/ML niche makes this a serious commercial play — every PyTorch user is a potential Mojo user. It’s the only post-Rust experimental systems language with a credible path to mass adoption as of 2026.
- The blockchain language explosion. Solidity (2015) dominated unchallenged for years. Then Move (2019, originally Diem/Facebook, now Aptos and Sui) introduced a resource type system — values that cannot be implicitly copied or dropped — which prevents an entire class of token-duplication bugs. Cairo (2020) brought zero-knowledge-proof-native programming. Vyper offers a more conservative EVM alternative. The lesson: smart-contract languages have to bake in formal-methods ideas because bugs cost millions and are unfixable post-deployment.
- Verification languages are quietly winning where it matters. F*‘s HACL* library is in Firefox’s NSS, the Linux kernel, and Microsoft Edge. Dafny is used at AWS for distributed-systems verification (the AWS S3 strong consistency proof was Dafny). These languages are tiny in user-count but enormous in deployed lines verified. Verification went from “research curiosity” to “what serious crypto and distributed-systems teams use” between 2015 and 2025.
- The transpiled-to-JS graveyard. CoffeeScript at peak (~2013) was on every Rails project. By 2017 ES6+ had absorbed every interesting feature (arrow functions, destructuring,
let/const, classes, template literals) and TypeScript had absorbed the rest plus added types. Today CoffeeScript, LiveScript, Iced, and most of their cohort are vestigial. The lesson: betting against a host language that is itself improving is a losing trade. ReScript survived because OCaml-strength types are a thing JS will never get. - Why most experimental systems languages stay pre-1.0. Rust raised the bar on what “production systems language” means: a working borrow checker, a working async story, a working package manager, a working ecosystem, multi-platform support, ABI stability commitments, an RFC process. Reaching that bar takes 8-10 years and a paid team. Most of the languages in the experimental list have a paid team of 0-3 people. Mojo and Carbon have well-resourced teams; most others don’t.
- The “pre-1.0 forever” risk. Several languages in this list (Vale, Austral, Cone, Bend) are research-flavoured and may never converge on 1.0 — that’s not a failure mode, that’s the point. They demonstrate ideas that get absorbed into the next generation of mainstream languages. Vale’s region references, Austral’s linear-as-default, Cone’s reference capabilities — these will likely show up in some mainstream language in the 2030s, just not necessarily under those names.
Citations
- Chandler Carruth, “Carbon Language announcement” (CppNorth 2022) — https://www.youtube.com/watch?v=omrY53kbVoA
- Chris Lattner, “Mojo: programming language for AI” (Modular blog 2023) — https://www.modular.com/blog/the-future-of-ai-depends-on-modularity
- Sam Blackshear et al., “Move: A Language With Programmable Resources” (Diem whitepaper 2019) — https://developers.diem.com/papers/diem-move-a-language-with-programmable-resources/2020-05-26.pdf
- StarkWare, “Cairo — a Turing-complete STARK-friendly CPU architecture” (2021) — https://eprint.iacr.org/2021/1063.pdf
- K. Rustan M. Leino, “Dafny: An Automatic Program Verifier for Functional Correctness” (2010) — https://www.microsoft.com/en-us/research/wp-content/uploads/2010/12/krml203.pdf
- Nikhil Swamy et al., “Dependent Types and Multi-Monadic Effects in F*” (POPL 2016) — https://www.fstar-lang.org/papers/mumon/
- HACL* / Project Everest — https://project-everest.github.io/
- Andreas Kling, “Jakt: a memory-safe systems lang for SerenityOS” (2022 talks) — https://github.com/SerenityOS/jakt
- Drew DeVault, “Hare’s design philosophy” (2022) — https://harelang.org/blog/2022-04-25-announcing-hare/
- Vladimir Ulogov, “Vale’s generational references” — https://vale.dev/blog/generational-references
- Solidity language docs — https://docs.soliditylang.org/
- AssemblyScript book — https://www.assemblyscript.org/introduction.html
- Grain language guide — https://grain-lang.org/docs/