# Big Book of R: a catalogue of 400 R books rendered as a Quarto book

> The project is a directory of links with a publishing pipeline around it, with the actual catalogue living in a Google Sheet and the chapters generated by an R script, which is a neat automation and also its main fragility.

**oscarbaruffa/BigBookofR** — The biggest collection of R books (and maybe later some other resources too)

- Repository: https://github.com/oscarbaruffa/BigBookofR
- Website: https://www.bigbookofr.com/
- Stars: 591 · Forks: 162
- Language: HTML
- License: not declared
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/oscarbaruffa-bigbookofr

## A link list with a publishing pipeline around it

The Big Book of R repository hosts a collection of over 400 R programming books, most of which are freely available, and the project is open to contributions of both free and paid books. The rendered site lives at bigbookofr.com, and the primary language of the repository is HTML, which tells you the output is a website rather than a book file.

The content itself is a catalogue. There is no tutorial text written by the project, and no attempt to sequence the books into a course. What the project adds is the machinery to keep a large list of links organised, rendered and searchable, and the machinery is where the interesting engineering is.

The repository layout shows the shape of it. There is a Quarto configuration file, a chapters directory holding the generated qmd files, a fetch_books.R script, a chapter_list.txt, an index.qmd, a start_here document and a book clubs document, plus the rendered output in a _book directory. Styling comes from a bigbook.scss file, with header.html and footer.html for the page furniture, and plausible-analytics.html for analytics and a .nojekyll marker for GitHub Pages.

One fact about the repository deserves attention before anything else, and it is easy to miss. The licence field is unknown, and there is no licence file in the top level listing. For a project whose output is a directory of links to other people's books, that is a reasonable situation. For a project whose code and structure you might want to reuse, it is a gap you have to resolve yourself.

## The catalogue lives in a Google Sheet, not in the repository

The single most consequential design decision in this project is where the data lives, and it is not in Git.

The metadata about the books is stored in a Google Sheet, and the link to that sheet is given in the readme. The library googlesheets4 appears in the required R libraries, and the fetch_books.R script is described as the script that fetches book data from Google Sheets, creates the qmd files in the chapters directory and generates the chapter_list.txt file.

So the repository holds the presentation layer, the Quarto configuration and the script, and the editorial content is a spreadsheet that anyone with the link can open. Contributions of books therefore go through the issue tracker and end up as rows in that sheet, and the site is rebuilt from them.

That has real advantages. Adding a book is a spreadsheet edit plus a script run, which is a much lower barrier than editing a book structure by hand, and the chapter files are generated rather than maintained, so there is no merge conflict between two people adding a book at the same time.

It also means the repository alone cannot rebuild the book. If the sheet is renamed, emptied, made private or abandoned, the pipeline loses its input, and the git history of the generated chapters becomes the only record of what was once listed. That is a deliberate trade of reproducibility for convenience, and for a public catalogue of freely available books it is a reasonable one, while for anything you depend on it is the thing to think about before copying the pattern.

## Setting up a local copy of the pipeline

The readme documents the toolchain in detail, and the prerequisites are specific.

Quarto is used to render the books, R has to be installed, and the required R libraries are dplyr, tidyr, stringr, googlesheets4 and readr.

```R
  library(dplyr)
  library(tidyr)
  library(stringr)
  library(googlesheets4)
  library(readr)
```

The project is best managed with RStudio or Visual Studio Code, and the repository is an RStudio project with a BigBookofR.Rproj file at the root, so the editor will open the right working directory.

The setup itself is a clone, the libraries, and then the pipeline.

```bash
   git clone [repository-url]
```

```R
   install.packages("dplyr")
   install.packages("tidyr")
   install.packages("stringr")
   install.packages("googlesheets4")
   install.packages("readr")
```

Then the script runs and the site is previewed locally with quarto preview, which the documentation says ensures that the newly fetched content renders correctly without errors before anything is committed.

```bash
   quarto preview
```

The reason to run this locally rather than only reading the deployed site is that the generated chapter files are the output of a script, and a script that talks to a spreadsheet can fail for reasons that have nothing to do with your machine, such as a changed sheet layout.

## Adding a book and adding a chapter are two different workflows

The readme is unusually clear about this distinction, and it is the part of the documentation worth reading in full before you contribute.

Adding a new book entry is the automated path. You run fetch_books.R, and the script automatically populates the chapters directory and generates the chapter_list.txt file, and the design goal stated in the readme is to facilitate the addition of new book entries without needing manual updates to the project structure. Nothing else has to change, because the chapter list is regenerated and the Quarto configuration calls the qmd files through that list.

Adding a new chapter, on the other hand, requires manual work in the Quarto configuration. The documented sequence is to remove all the content in the chapters directory and the existing chapter_list.txt file, re-run fetch_books.R to fetch the latest data and generate updated qmd files, then manually update _quarto.yml to incorporate the changes from the new chapter_list.txt so that the chapter structure lines up, and finally run quarto preview to verify that everything renders correctly before committing.

The mechanism behind that is what _quarto.yml does. The readme describes it as the primary configuration file that manages the rendering of books and calls all the qmd files, and the chapter_list.txt holds the list of qmd files with their paths, generated by the script. So the file is a generated index that the configuration consumes, which is why adding a book is free and adding a chapter is not.

That is a sensible division of labour, and it is also the design a team copying this pattern would most want to change, because a configuration file that has to be edited by hand every time the set of chapters changes is the part most likely to drift.

## Releases, rendering and where the site is hosted

The release history is thin. There is a single listed release, 2.0, described as a remodelled backend and published on 2022-01-02, and there is no release since. The repository itself is not archived, and the last push was on 2026-04-26, so changes continue to land on the default branch even though the published version history has not moved in years.

The deployment path is Quarto's own. The readme points at the Quarto documentation for setting up GitHub Pages and GitHub Actions, and the presence of a .nojekyll file, a plausible-analytics.html include and a rendered _book directory are all consistent with a static site published through GitHub Pages from the Quarto output.

The rendering chain is worth spelling out because it is the part that produces the site. The spreadsheet holds the metadata, fetch_books.R turns rows into qmd chapters and a chapter list, _quarto.yml drives the rendering of those chapters, and Quarto produces HTML into _book. Each stage has a single responsibility, and the only stage that is unusual, compared with a normal Quarto book, is the second one.

That structure also explains what the .Rhistory file in the repository root is: the R session history of whoever ran the pipeline last, committed by accident, and a small illustration that this is a working project rather than a polished package.

## Where Big Book of R is the wrong tool

Four mismatches, and the first one is about what a catalogue can do for a learner.

A catalogue is not a curriculum. Big Book of R answers the question of what exists, and it does that at a scale that a hand written list could not reach, with over 400 entries and a filterable, searchable, continuously updated site. It does not tell a beginner what to read first, and the readme's start_here and book clubs documents are the acknowledgement of that gap. If your need is a learning path, this is a directory to start from rather than a path to follow.

The second is the dependency on an external spreadsheet. The pipeline is only as available as the sheet, and the sheet is not in version control. That is fine for a public list and wrong for a catalogue your organisation depends on.

The third is the toolchain. To add a book you need Quarto, R, five R libraries and a spreadsheet connection, and to preview the result you run a Quarto server. A team that just wants a list of links will find that heavy, and a team that wants a list of links maintained by hand will find it unnecessary.

The fourth is the licence gap. The repository does not state a licence, so if you want to reuse the pipeline, the styling or the structure in your own project, you have no permission to rely on, and you should ask the maintainer rather than assume. The readme does point to the issue tracker for exactly this kind of question, and the contributing guidelines are referenced there.

Finally, a catalogue of links ages. Books get superseded, links rot, and the project says the collection is mostly free books with some paid ones, so what you find is a record of what existed when the sheet was last updated.

## Conclusion

Big Book of R is the right starting point for a team that wants a browsable, continuously updated index of R books, and for anyone who wants to copy the pattern of a spreadsheet driven, script generated, Quarto rendered directory. It is the wrong resource for a structured learning path, since it is an index rather than a curriculum, and it is the wrong base to fork if you need the catalogue to live in version control. Before adopting the pattern, read the fetch_books.R script to see what it generates, decide where your own metadata will live, and check the licence, which the repository does not state.

## FAQ

### What is the Big Book of R?

It is a repository hosting a collection of over 400 R programming books, most of them freely available, and open to contributions of both free and paid books. The collection is rendered as a website with Quarto and published at bigbookofr.com.

### Where is the book list stored for Big Book of R?

The metadata about the books is stored in a Google Sheet, and the script fetch_books.R fetches the data from that sheet, creates the qmd files in the chapters directory and generates the chapter_list.txt file. The repository therefore holds the rendering pipeline rather than the catalogue itself.

### What do I need to run Big Book of R locally?

Quarto, an R installation, the R libraries dplyr, tidyr, stringr, googlesheets4 and readr, and either RStudio or Visual Studio Code, since the project is managed as an RStudio project. After cloning, you run fetch_books.R and then quarto preview to check the rendering.

### What is the difference between adding a book and adding a chapter to Big Book of R?

Adding a book is automated: run fetch_books.R and it repopulates the chapters directory and regenerates chapter_list.txt. Adding a chapter is manual, because the readme asks you to clear the chapters directory and the chapter list, re-run the script and then edit _quarto.yml so the configuration matches the new chapter structure.

## Sources

- [Issues](https://github.com/oscarbaruffa/BigBookofR/issues)
- [oscarbaruffa/BigBookofR on GitHub](https://github.com/oscarbaruffa/BigBookofR)
- [Project website](https://www.bigbookofr.com/)
- [README](https://github.com/oscarbaruffa/BigBookofR/blob/main/README.md)
- [Releases](https://github.com/oscarbaruffa/BigBookofR/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/oscarbaruffa-bigbookofr