r-source: an hourly GitHub mirror of the R sources

What the repository is, and what it is not

The repository description is precise and short. It is a read-only mirror of the R source code from the Subversion repository at the R project, updated hourly, and the build instructions are on the wiki page.

Three facts in that sentence matter. The mirror is read-only, so it exists for convenience rather than as a place to contribute. It is fed from Subversion, which is the canonical home of the R sources, so the GitHub tree is a projection of the real thing and lags by at most an hour. And the build instructions are deliberately not in the tree, which is a sensible choice for a mirror whose contents are replaced wholesale every hour, because anything you wrote in the repository would be overwritten.

The default branch is trunk, which is the Subversion name for the main line of development, and that is a useful detail for navigation, because the branch names in a Subversion repository do not follow the Git convention.

The repository layout is the R source tree itself, which is worth reading as a map of the language. There is the configure script and its autoconf source, the makefiles including one for the Fortran compiler and one for Windows, a config site file for the build configuration, the src directory with the interpreter and the built in primitives, the doc directory with the manuals, the tools directory, the tests directory, the translations in the po directory, the macro definitions in m4, the shared data and the etc directory, a ChangeLog, the INSTALL file, the COPYING file with the GNU licence, and a VERSION file next to a VERSION-NICK file for the nickname of the release.

The licence is GPL-2.0, and the last push to the repository was on 2026-10-15.

What R is, in the words of its own README

The tree carries the original R README, and it is a short and unusually direct description of the language.

The directory contains the source code tree for R, a language which is not entirely unlike versions 3 and 4 of the S language developed at AT&T Bell Laboratories by Rick Becker, John Chambers and Allan Wilks. R is free software distributed under a GNU-style copyleft.

The implementation description is the part that tells you what kind of system you are reading. The core of R is an interpreted computer language with a syntax superficially similar to C, but which is actually a functional programming language with capabilities similar to Scheme. The language allows branching and looping as well as modular programming using functions, and most of the user-visible functions are written in R, calling upon a smaller set of internal primitives. It is possible for the user to interface to procedures written in C or Fortran languages for efficiency, and also to write additional primitives.

So R is a small interpreted core with a large library written in the language itself, and the extension points are the primitives and the packages. The distribution contains functionality for a large number of statistical procedures, among them linear and generalized linear models, nonlinear regression models, time series analysis, classical parametric and nonparametric tests, clustering and smoothing, along with a large set of functions providing a flexible graphical environment for creating various kinds of data presentations.

The package specification allows the production of loadable modules for specific purposes, and several thousand contributed packages are made available through the CRAN sites.

The history, and who can change the source

The history section is short and it is the answer to the question every contributor asks about a project of this age.

R was initially written by Robert Gentleman and Ross Ihaka of the Statistics Department of the University of Auckland, and in addition a large group of individuals has contributed to R by sending code and bug reports.

Since mid-1997 there has been a core group who can modify the R source code archive, and that group is listed in the file doc/AUTHORS, which is the first file to look for if you want to know who decides.

The release dates are the interesting historical record. R 1.0.0 was released on 29 February 2000, 2.0.0 on 4 October 2004, 3.0.0 on 3 April 2013 and 4.0.0 on 24 April 2020. And the README notes that this file has been minimally revised since the release of R 1.0.0, which is a claim you can check, because the document in the tree is the one that shipped in 2000 with a few edits.

That combination, a document that has barely changed in a quarter of a century and a project that has shipped four major versions in that time, is a good description of what a mature language looks like from the inside. The interface is stable, the internals are not, and the people who can change the internals are a named list.

The books, and the documentation pipeline

The present status section describes R against the S literature, which is the clearest statement of what the language was built to be.

The present version implements most of the functionality in the 1988 book The New S Language, known as the Blue Book, and many of the applications, and a large part of the functionality from the 1992 book Statistical Models in S, the White Book, and the 1998 book Programming with Data, the Green Book.

The documentation story is the most interesting part of that section. All the R functions have been documented in the form of help pages in an output-independent form which can be used to create versions for HTML, PDF, text and other formats. A Reference Index of more than 2300 pages collects most of the help pages, with a longer version of more than 3900 pages that includes all the help pages and the recommended packages, and it can be obtained as a PDF.

The manual An Introduction to R provides a more user-friendly starting point, and there is an FAQ, a draft of the R Language Definition manual, and more specialised manuals on administration, on data import and export and on extending R. The INSTALL file has the instructions for how to generate these documents.

That output-independent format is the quiet engineering decision that makes R's documentation work at all, and it is the reason the same source produces a book, a website and a help system. When you read the doc directory in the mirror, you are reading the input to a documentation build rather than a finished manual, and the INSTALL file explains how to turn it into the artefacts you have read.

The goals, including the efficiency R gave up

The goals section is where the project explains itself in the first person, and one paragraph in it is unusually candid.

The aim at the start of the project was to demonstrate that it was possible to produce an S-like environment which did not suffer from the memory demands and performance problems which S has. Somewhat later, the authors started to turn R into a real system, but they lost a large part of the efficiency advantage in the process, so they revised the memory management mechanism and implemented delayed loading of R objects. A lot of performance tuning has been done, including the ability to use tuned linear-algebra libraries.

That is a project admitting, in its own README, that the redesign cost something and then paying the bill. The delayed loading of objects and the pluggable linear algebra are the visible result, and a reader of the source tree will find both of those ideas in the interpreter rather than in a design document.

The longer-term goals are listed after that. They include exploring new ideas such as virtual objects and component-based programming, and expanding the scope of existing ones like formula-based interfaces. The team also wanted to get a handle on a general approach to graphical user interfaces, preferably with cross-platform portability, and to develop better 3-D and dynamic graphics.

Read together with the rest of the README, the picture is of a project that knows exactly what it is, a statistical computing environment built on a functional core, and that is candid about both the compromise it made and the ideas it has not finished.

The README closes with the sign-off from the R Core Team, and the mirror is updated every hour to whatever that team has committed.

Editorial conclusion

Adopt r-source as a reading and searching tool for the R implementation, because the mirror is refreshed every hour and the whole tree is greppable on GitHub. Do not send contributions there, since the repository is a read-only mirror and the upstream is the Subversion tree, so a pull request against the mirror would go to the wrong place. Before you build, read the wiki page for the build instructions, since the repository carries the build system but not the recipe for running it, and expect to follow the source layout rather than the git branch names to navigate the tree.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-2.0
3. Project website
4. README
5. wch/r-source on GitHub