A typed superset of R — static type checking, modules, sum types and interfaces, compiled to idiomatic, readable R.
Just add types. TypR is a typed superset of R that compiles to readable, stock R. No runtime, no new dependencies — just static verification that catches wrong argument types, undocumented returns, and silent coercions before your code ever runs.
| R today | TypR |
normalize <- function(x, na.rm = FALSE) {
stopifnot(is.numeric(x), length(x) > 0)
if (na.rm) x <- x[!is.na(x)]
(x - mean(x)) / sd(x)
} |
let normalize <- fn(x: [num], na.rm: bool = false): [num] {
if (na.rm) { x <- x[!is.na(x)] };
(x - mean(x)) / sd(x)
}; |
| Channel | Command |
|---|---|
| Cargo | cargo install typr |
| Binaries | latest release — Linux, macOS, Windows (x86_64 + aarch64) |
| Docker | docker run --rm -it fabricehategekimana/typr:latest |
| RStudio / Positron | typr.runner_*.tar.gz from the latest release |
| VS Code / Positron | search TypR in the Marketplace |
| Vim / Neovim | typr-vim-*.tar.gz from the latest release, or a plugin manager — see editors/vim |
All channels are published from the same tag and carry the same version number. See RELEASING.md.
typr new my_package # scaffold a project
typr check # type-check without emitting
typr build # transpile to R/
typr run # build and run
typr test # run testthat suites
typr document # generate .Rd documentation
typr pkgdown # build a documentation website
typr repl # interactive session
typr tutor # learn TypR step by step, like vimtutor
typr lsp # language server (used by the editor extensions)
typr mcp # MCP server (exposes the compiler to AI agents)typr mcp runs an MCP server over stdio, giving AI
agents (Claude Code, Claude Desktop, etc.) direct access to the compiler — no shelling out
to typr check/typr build and parsing text output. Everything runs in-process: no
filesystem, no project directory, no .typr_cache.
Tools exposed today (see crates/typr-mcp):
| Tool | What it does |
|---|---|
check |
Type-checks TypR source, returns {ok, diagnostics[{code, message}]} with stable T0xx/S0xx codes |
build |
Same as check, plus the transpiled R code (r_code) — produced even when there are type errors |
tutor_lessons / tutor_lesson / tutor_check / tutor_hint |
The TypR tutor's lessons, graded by the compiler — the same course as typr tutor |
The server also offers a tutor prompt: pick it in your client (in Claude Code,
/mcp__typr__tutor) and the assistant becomes a tutor that walks you through the lessons,
grades your attempts without writing them for you, and points you to the documentation
pages each lesson opens onto.
Point a client at the typr binary with the mcp argument. After cargo install typr,
typr is on PATH, so a client config (e.g. Claude Desktop's/Claude Code's mcpServers
block) just needs:
{
"mcpServers": {
"typr": {
"command": "typr",
"args": ["mcp"]
}
}
}Building from a local checkout instead of installing? Point command at
target/debug/typr (or target/release/typr) directly.
Like vimtutor, typr tutor teaches by doing: it creates a typr-tutor/ folder holding
thirteen short lessons, each a TypR file whose comments explain and whose code you complete.
typr tutor check grades your answer with the compiler and, once it passes, lists the
documentation pages to read next. typr tutor hint, list, reset N and solution N
do what they say. No AI needed — and if you want one, the MCP server's tutor prompt runs
the same lessons. Lessons live in crates/typr-mcp/data/tutor/.
crates/typr-core type checking and transpilation
crates/typr-cli command-line interface
crates/typr-lsp language server
crates/typr-mcp MCP server exposing the compiler to AI agents
crates/typr-wasm WASM build powering the playground
editors/vscode VS Code / Positron extension
editors/rstudio RStudio addins (typr.runner)
editors/vim Vim / Neovim plugin
docker/ container image
cases/ reproducible bug catalog (`typr case`)
cases/ holds a numbered, reproducible catalog of past bugs with golden
outputs — the best entry point for understanding a behaviour is usually the case
that pinned it down. cargo test --workspace runs the suite.
Apache-2.0