Language and runtime support
LM15 is one design implemented separately in each language. There is no shared native core underneath: the Python package is pure Python, the Go module is pure Go, and so on. What keeps them the same is a shared contract: a written specification and a corpus of recorded provider traffic that every language is graded against. Two languages that pass the same contract build the same request from the same program and read the same answer from the same reply.
This page lists where each language stands. The Releases page lists the versions.
Released languages
Section titled “Released languages”These five are published, graded against the current contract, and used in every example on this site.
| Language | Version | Install | Runs on |
|---|---|---|---|
| Python | 2.0.0, stable | pip install lm15 |
Python 3.10 or newer; Linux, macOS, Windows |
| TypeScript | 2.0.0, stable | npm install @lm15/lm15 |
Node.js 22 or newer; browsers (@lm15/lm15/browser) |
| Rust | 2.0.0, stable | cargo add lm15 |
stable Rust; native targets and wasm32 |
| Go | v2.0.0, stable | go get github.com/lm15-dev/lm15-go/v2 |
Go 1.26.2 or newer; Linux, macOS, Windows, GOOS=js |
| R | 2.0.0, stable | remotes::install_github("lm15-dev/lm15-r") (on its way to CRAN: install.packages("lm15") once it is accepted) |
R 4.1 or newer; Linux, macOS, Windows; browsers through webR |
Stable means the core won’t change in a way that breaks your program until the next major version. For all five, the core is the same: requests and responses, streaming, tools, structured output, media inputs, reasoning controls, errors, credentials and model listing. Files, batches, media generation, stored prompt caches, realtime sessions, reading OpenAI Chat Completions requests, and signing in with an account are provisional in every language: they may still change within a major version, with a notice.
Python, TypeScript, Rust and Go have no required third-party dependency:
each uses its language’s standard library, including for HTTP. R’s standard
library has no HTTP client, JSON reader or cryptography, so the R package
uses the standard R packages for them: curl, jsonlite and openssl. Python’s realtime
sessions use the optional websockets package (pip install 'lm15[live]'),
and Rust’s examples use Tokio to run async code.
How they are checked
Section titled “How they are checked”Every change to any of the five is graded by the contract’s harness, which compares the exact requests each language builds and the responses it reads with recorded provider traffic. Each passes every check of the contract version it pins (on 2026-11-01: 1,968 checks, the same contract version for all five). Each language also runs its own tests on Linux, macOS and Windows, and every example on this site is run in every language and must send the same request as Python does. Before being called stable, each was also run against the real providers.
Saved sign-ins are shared across languages: a login saved from Python is used and renewed from Go, and two programs in different languages renew one token exactly once. All five released versions have saved sign-ins (Python since 1.0.1, Go since v1.1.0-rc.1, TypeScript and Rust since 1.0.0-rc.2, R since 1.0.0).
In the browser
Section titled “In the browser”TypeScript runs in the browser directly. Rust and Go compile to WebAssembly, and the playground runs the real Rust and Go packages that way, as well as Python through Pyodide and R through webR. In a browser, a provider must allow requests from web pages (Anthropic needs an explicit opt-in, which LM15 sends), and sign-in methods that open a local listener are not available.
Languages in development
Section titled “Languages in development”| Language | Where it stands | Install |
|---|---|---|
| Julia | 2.0.0, the package LanguageModel15, passes all 1,968 checks of the current contract, like the released languages; it waits for Julia’s package registry. Julia 1.10 or newer. |
From GitHub: Pkg.add(url="https://github.com/lm15-dev/LanguageModel15.jl") |
Early ports
Section titled “Early ports”Java, Ruby, Swift and .NET exist as ports written against the contract of September 11. They are not published and are not kept up to date with the released languages; their repositories say how far each one got. Use them to evaluate LM15 in those languages, not in production.