Awesome R package development

A curated list of awesome tools to assist 📦 development in R programming language.

What is included?

• Only tools helpful for package development are included, and not other resources (e.g. books).
• All relevant tools are included, irrespective of their availability on CRAN.
• Tools which are part of publicly archived/retired GitHub repositories are not included.

If you wish to suggest any additional tools, please make a PR or create an issue here.

Contributing

Please note that the awesome-r-pkgtools project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

Note

If you are not using the latest release of pandoc, please change only the README.qmd document to avoid possibly large irrelevant diffs.

Swiss army knives 🛠

Tools useful across all stages of package development (some of these are meta-packages and their component packages are also included in respective sections for the sake of completeness), irrespective of whether package is meant to be submitted to CRAN or to Bioconductor.

• {devtools}

• {usethis}

• {biocthis}

• {packager}

• {pacs}

Package skeletons 💀

• {pkgkitten} (useful for creating new packages for R)

• {rcompendium} (to make the creation of R package/research compendium easier)

• {skeletor} (An R Package Skeleton Generator)

Shiny

• {golem} (framework for building shiny applications)

• {leprechaun} (leaner framework for building shiny applications)

• {rhino} (a framework to build high quality, enterprise-grade Shiny apps at speed)

• {fusen} ({rmarkdown}-based)

Meta-packages

• {pkgverse} (for package meta-verse)

• {metamakr} (for package meta-verse)

Naming things 🧸

• {available} (to check if a package name is available to use)

• {collidr} (to check for namespace collisions)

• {changer} (to change the name of an existing R package)

Working with package components

• {rprojroot} (accessing files w.r.t. package root directory)

• {desc} (manipulating DESCRIPTION files)

• {withr} (to manage package side effects by safely and temporarily modifying global states)

• {pkgload} (to simulate the process of installing and loading a package)

• {pkgbuild} (to find tools needed to build packages)

Package configuration

• {config} (to manage environment specific configuration values)

Package management tools

• {pkgcache} (to cache ‘CRAN’-like metadata and packages)

Documentation 📚

Manual

• {roxygen2} (to generate R package documentation from inline R comments)

• {Rd2roxygen} (in case you inherit a project where documentation was not written using {roxygen2})

• {sinew} (generate {roxygen2} skeletons)

• {roclang} (helpers for diffusing content across function documentation)

• {Rdpack} (for inserting references, figures, and evaluated examples in Rd docs)

• {roxygen2md} (to allow Markdown syntax usage in {roxygen2} documentation)

• {rd2markdown} (to convert .Rd package documentation files into markdown files)

• {rd2list} (converts Rd docs to a human-readable list)

• {pasteAsComment} (RStudio addin for pasting copied code as roxygen comment)

• roxygen2Comment (Rstudio addin for adding and remove {roxygen2} comment)

Math rendering in the manual

• {katex} (to convert latex math expressions to HTML for use in package manual pages)

• {mathjaxr} (provides ‘MathJax’ and macros to enable its use within Rd files for rendering equations in the HTML help files)

Vignettes

• {knitr} (a general-purpose tool for dynamic report generation to be used as a vignette builder for R package vignettes)

• {rmarkdown} (to convert R Markdown documents to a variety of formats)

• {quarto} (provides R interface to frequently used operations in the Quarto CLI)

• {prettydoc} (creates lightweight yet pretty vignettes)

• {learnr} (to turn any R Markdown document into an interactive tutorial)

Website

• {pkgdown} (static website for package documentation)

• {gitdown} (software changes as a gitbook)

• {altdoc} (use docute or docsify to create a static website for package documentation)

Translation

• {potools} (for translating messages and checking the “health” of the messaging corpus)

Lifecycle

• {lifecycle} (to manage the life cycle of exported functions)

Badges and stickers

• {badger} (query information and generate badges for using in README and GitHub Pages)

• {hexSticker} (helper functions for creating reproducible hexagon sticker purely in R)

• hexwall (to create a wall of hexstickers)

Presentation

• {xaringan} (an R Markdown output format for remark.js slides)

Book

• {bookdown} (authoring framework for books and technical documents with R Markdown)

Change log and versioning

• {fledge} (streamlines the process of updating change logs and versioning R packages developed in git repositories)

• {newsmd} (utilities to add updates to the NEWS.md file)

Documentation quality ✒️

• {docreview} (to check quality of docs)

• {spelling} (to check for spelling mistakes)

• {gramr} (for grammar suggestions)

Unit testing 🧪

General

• {testthat} (a testing framework for R that is easy to learn and use; also provides snapshot testing)

• {patrick} (for parametrized unit testing with {testthat})

• {tinytest} (zero-dependency unit testing framework that installs tests with the package)

• {RUnit} (a standard Unit Testing framework, with additional code inspection and report generation tools)

• {testit} (a simple package for testing R packages)

• {roxytest} (inline {testthat} tests with {roxygen2})

• {roxut} (to write the unit tests in the same file as the function)

• {exampletestr} (tests based on package examples)

• {unitizer} (simplifies regression tests by comparing objects produced by test code with earlier versions of those same objects)

• {r-hedgehog} (property based testing)

• {autotest} (automatic mutation testing of R packages)

Markdown documents

• {pandoc} (to check Markdown documents across various version of Pandoc)

Shiny applications

• {shinytest} (testing Shiny apps)

• {shinytest2} (testing Shiny apps using a headless Chromium web browser)

Web/database applications

• {httptest} (a test environment for HTTP requests in R)

• {httptest2} (the same for {httr2} package)

• {dittodb} (makes testing against databases easy)

Visual regression testing

• {vdiffr} (for visual regression testing with {testthat})

• {gdiff} (for performing graphical difference different package or R versions)

Mock testing

• {mockthat} (function mocking for unit testing to third-party packages)

• {mockr} (allows mocking functions in the package under test)

• {testdown} (turn {testthat} results into a {bookdown} project)

Helpers for testing frameworks

• {testthis} (RStudio addins for working with files that contain tests)

• {xpectr} (builds unit tests with the {testthat} package by providing tools for generating expectations)

Code analysis 🗂⏱

General

• {codetools} (code analysis tools for R)

• {goodpractice} (Swiss army knife for good practices)

• {inteRgrate} (provides an opinionated set of rules for R package development)

• {pkgcheck} (checks if package follows good practices recommended for packages in the rOpenSci ecosystem)

• {pkgstats} (a static code analysis tool)

• {rchk} (provides several bug-finding tools that look for memory protection errors in C source code using R API)

• {sourcetools} (tools for reading, tokenizing, and parsing R code)

• {precommit} (git hooks for common tasks like formatting files, spell checking, etc.)

Code coverage

• {covr} (to compute code coverage)

• {covrpage} (to include summary README of code coverage and more detailed information about tests)

• {covtracer} (provides tools for contextualizing tests)

Lint detection

• {lintr} (static code analysis)

• {adaptalint} (infer code style from one package and use it to check another)

• {roger} (provides tools for grading the coding style and documentation of R scripts)

• {cleanr} (tests code for some of the most common code layout flaws)

Code complexity

• {cyclocomp} (to index the complexity of a function)

Code similarity

• {dupree} (identifies code blocks that have a high level of similarity within a set of R files)

• {rscc} (provides source code similarity evaluation by variable/function names)

• {SimilaR} (quantifies the similarity of the code-base of R functions by means of program dependence graphs)

Compiled code

• {memtools} (to solve memory leaks)

• {cppcheckR} (to check C and C++ code using Cppcheck)

JavaScript code

• {jshintr} (to run JSHint for static code analysis for JavaScript code included in the package)

Lines of code

• {cloc} (counts blank lines, comment lines, and physical lines of source code in source files)

Code performance ⏱️

Benchmarking

• {bench} (provides high precision benchmarks for R expressions)

• {microbenchmark} (provides infrastructure to accurately measure and compare the execution time of R expressions)

• {touchstone} (benchmarking pull requests)

Profiling

• {profvis} (to profile and visualize profiling data)

• {proffer} (to create friendlier, faster visualizations for profiling data)

• {jointprof} (to profile packages with native code in C, C++, Fortran, etc.)

Formatting 🧽

• {styler} (to format code according to a style guide)

• {stylermd} (to format text in Markdown documents)

• {formatR} (to format R source code)

• AlignAssign (RStudio addin that aligns the assignment operators within a highlighted area)

• {snakecase} (helpful for having consistent case while naming objects in the package)

Dependencies ⚖️

• {pkgdepends} (to find recursive dependencies of from various sources)

• {deepdep} (to visualize and explore package dependencies)

• {itdepends} (to assess usage, measure weights, visualize proportions, and assist removal of dependencies)

• {DependenciesGraphs} (to visualize package dependencies)

• {pkgnet} (to build a graph representation of a package and its dependencies)

• {functiondepends} (to find functions in an unstructured directory and explore their dependencies)

• {pkgndep} (checks the heaviness of the packages used)

• {oysteR} (to secure package against insecure dependencies)

• {attachment} (to deal with package dependencies during package development)

CRAN checks, submission, and status 📬

• {rcmdcheck} (to run R CMD check form R programmatically)

• {rhub} (to run R CMD check on CRAN architectures)

• {checkhelper} (to help avoid problems with CRAN submissions)

• {foghorn} (to check for results and submission portal status)

• {urlchecker} (to checks for URL rot)

Usage 🙈

• {cranlogs} (for computing CRAN download counts)

• {packageRank} (for visualizing CRAN download counts)

• {dlstats} (provides download statistics for packages)

CI/CD 📟

CI/CD: continuous integration and either continuous delivery or continuous deployment

• actions (for GitHub Actions)

• r-appveyor (for AppVeyor)

• {tic} (for Circle CI and GitHub Actions)

• {jenkins} (for Jenkins CI)

• {cronR} (to schedule R scripts/processes with the cron scheduler)

Security/Privacy 👮

• {digest} (for the creation of hash digests of arbitrary R objects)

• {hash} (implements a data structure similar to hashes in Perl and dictionaries in Python but with a purposefully R flavor)

• {gpg} (GNU privacy guard for R)

Build systems

• {fakemake} (to mock Unix Make build system in case it is unavailable)

Validation frameworks

• {valtools} (in clinical research and drug development)

Debugging 🔭

• {debugme} (provides helpers to specify debug messages as special string constants, and control debugging of packages via environment variables)

• {debugr} (tools to print out the value of R objects/expressions while running an R script)

• {winch} (provides stack traces for call chains that cross between R and C/C++ function calls)

• {flow} (to visualize as flow diagrams the logic of functions, expressions, or scripts, which can ease debugging)

Input validation 🔬

• {checkmate} (fast and versatile argument checks)

• {assertthat} (to declare the pre and post conditions that you code should satisfy and to produce friendly error messages)

• {assertive} (provides readable check functions to ensure code integrity)

• {pkgcond} (better error messages for package users)

• {dreamerr} (a simple and intuitive, yet powerful and flexible, way to check the arguments passed to a function and to offer informative error messages)

Package metadata 🖨

• {codemetar} (provides utilities to generate, parse, and modify codemeta.jsonld files automatically for R packages)

• {codemeta} (a leaner version of {codemetar})

• {cffr} (provides utilities to generate, parse, modify and validate CITATION.cff files automatically for R packages)

• {pkgapi} (to create the map of function calls in a package)

• {packagemetrics} (for comparing among packages)

• {devtoolbox} (to create a summary report for R package and to extract dependency statistics in a tidy data frame)

• {pkgattrs} (useful for getting information on the contents of any R package)

• {foreman} (for unpacking, interrogating and subsetting R packages)

• {sessioninfo} (to include R session information)

Reverse dependency checks 📡⚰️

• {revdepcheck} (for automated, isolated, reverse dependency checking)

• {xfun} (specifically, xfun::rev_check())

Gratitude 🙏💌

To thank the contributors or maintainers of packages you rely on.

• {thankr} (to find out who maintains the packages you are using)

• {allcontributors} (to help acknowledge all contributions)

Docker container 🛍

• {containerit} (to package R script/session/workspace and all dependencies as a Docker container by generating a suitable Dockerfile)

• {usethat} (to automate analytic project setup tasks)

Integration with other languages 🔗

C++

• {Rcpp}

• {cpp11}

Fortran

• {RFI}

Python

• {reticulate}

Rust

• {cargo}

• {hellorust}

.NET Framework

• {rClr}

JavaScript/HTML/CSS

• {htmltools}
• {packer}

Julia

• {JuliaCall}

Upkeep 🧹

• {TODOr} (RStudio addin to list things that you need to do or change)

Sundry 🗒

• {prefixer} (prefix function with their namespace )

• {rstudioapi}(to conditionally access the RStudio API from CRAN packages)

• {gitignore} (to fetch gitignore templates)

• {DIZutils} (helpers for packages dealing with database connections)