ry is a fast R runtime, built to run your existing R code unchanged, plus a type checker and new language features that make your code safer and faster.
ry run script.R # run a script (no file: open the console)
ry check # find bugs without running the code
ry fmt # format your R filesry is in beta. The checker, formatter, editor support and package loader are ready for daily use,
but the runtime does not run all R code yet: a script that needs something it lacks stops with an
error that names it, and ry R script.R runs the script on GNU R instead.
Install ry, then follow Adopting ry.
How much faster ry's runtime is than GNU R, for each benchmark suite:
- Public R JIT benchmarks: 2.66x. 54 standard programs from R compiler research (Ř, rcp).
- Package test suites: 1.91x. 26 pinned CRAN packages, each running its own test suite.
- Numeric kernels: 4.81x, 15x in typed ry. 16 small programs we wrote whose time goes into loops, recursion and arithmetic on numbers.
- Application workloads: 1.95x, 21x in typed ry. 15 programs we wrote in the shape of package and business code: calls, dispatch, conditions, records, tables.
Each number is the geometric-mean speed-up over GNU R 4.6.2 (above 1x is faster), from 10 paired rounds on Linux. Benchmarks shows every program and how it is measured.
R reports a value of the wrong type only when the line that uses it runs, which can be an hour into
a long job, or never in the tests that skip that branch. ry check finds these bugs without running
the code. Set typing = true in ry.toml, and it infers types from your plain R, with no
annotations:
apply_discount <- function(price, rate) price * (1 - rate)
apply_discount(100, "0.2")
To check more than inference can see:
- Annotations state what a function takes and returns, in a
#:comment that keeps the file plain R (#: fn(price: double, rate: double) -> double) or inline (function(price: double, rate: double) -> double). - Strict mode (
strict = true) makes every value whose type is not known an error. ry check --annotatewrites the inferred types into your files.
Even without typing, ry check reports syntax errors, names that do not resolve, unused values,
and lints such as x == NA, and ry check --fix applies the safe fixes.
→ Adopting ry
On top of R, ry adds a small typed language of its own: records, tuples, tagged unions with
exhaustive match, errors as values, nominal types, a typed DataFrame built on Polars, and a
standard library. Code that uses them runs only on ry's runtime, and the plain R code beside it
keeps working. When you add a case to a tagged union, ry check points you at every match that
does not handle it:
type Payment =
| :Paid(amount: double)
| :Refunded(amount: double)
| :Pending
balance <- function(payment: Payment) -> double {
match (payment) {
:Paid(amount = a) => a
:Refunded(amount = a) => -a
}
}
balance(@Payment(:Paid(amount = 10)))
- Editor support. A language server for VS Code, Zed and any other LSP editor: diagnostics as you type, hover with inferred types, completion, go to definition, references, rename and quick fixes. → Editors
- Formatter.
ry fmtgives every R file one consistent layout, so diffs show changes in logic rather than whitespace. → Formatting rules - Package loader.
ry load, andry runinside a package, load the package from source like devtools'load_all(), but lazily, and reload only what you changed: on a package of about 300,000 lines, a reload takes under 100 ms instead of about 9 s. → Package loading
When AI agents write much of the code, you need tools that verify a codebase without a person reading every line, and type checking is one of them. It checks every line on every change, including the lines no test reaches.
Teams with R codebases of more than 100,000 lines that cannot easily move to another language.
No. Let Claude rewrite your code in Rust.
It started as "the roughly good enough language server", which people shortened to Roughly. When it gained a type checker, it was rewritten from scratch and renamed ry.
The ry program is GPL, like GNU R, because parts of its runtime are translated from R's own C
code. The analysis libraries (the parser, type checker, formatter and language-server features) are
UPL-1.0, so any project can reuse them. The C headers that packages compile against are
LGPL-2.1-or-later, as R's own are, so a compiled package can choose its own licence. The editor
extensions are MIT. Licensing gives the exact version
for every part.