A curated list of awesome tools for R package development
Indrajeet Patil
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/Bioconductor.
- 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.
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.
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 the package is meant to be submitted to CRAN or Bioconductor.
{pkgkitten}
(useful for creating new packages for R)
{rcompendium}
(to make
the creation of R package/research compendium easier)
{r.pkg.template}
(an opinionated R package template with CI/CD built-in)
{skeletor}
(An R
Package Skeleton Generator)
{fusen}
(to build a
package from RMarkdown files)
{litr}
(to write a complete R package in a single R markdown document)
{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)
{pkgverse}
(for package meta-verse)
{metamakr}
(for package
meta-verse)
{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)
{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)
{config}
(to manage
environment specific configuration values){pkgcache}
(to
cache โCRANโ-like metadata and packages){roxygen2}
(to generate R package
documentation from inline R comments)
{Rd2roxygen}
(in
case you inherit a project where documentation was not written using
{roxygen2}
)
{roxyglobals}
(to
generate global variables with {roxygen2}
documentation)
{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)
{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)
{mathml}
(translates
R expressions to โMathMLโ or โMathJaxโ so that they can be rendered
in HTML manual and Shiny apps)
{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)
{R.rsp}
(for
incorporating static and dynamic vignettes)
{RmdConcord}
(to provide
support for concordances in R Markdown files)
{prettydoc}
(creates lightweight yet pretty vignettes)
{learnr}
(to turn any R
Markdown document into an interactive tutorial){pkgdown}
(static website for package
documentation)
{gitdown}
(software
changes as a gitbook)
{altdoc}
(use
docute
, docsify
, or MkDocs
to create a static website for
package documentation)
{potools}
(for
translating messages and checking the โhealthโ of the messaging
corpus){lifecycle}
(to manage the life
cycle of exported functions){badger}
(to query
information and generate badges for use in README
)
{badgen}
(provides
bindings to badgen
to
generate beautiful โsvgโ badges in R without internet access)
{hexSticker}
(helper functions for creating reproducible hexagon sticker purely
in R)
{hexFinder}
(to
scavenge the web for possible hex logos for packages)
hexwall
(to
create a wall of hexstickers)
{xaringan}
(an RMarkdown
output format for remark.js
slides){bookdown}
(authoring framework for books and technical documents with R
Markdown){fledge}
(to streamline the process
of updating change logs and versioning R packages developed in git
repositories)
{newsmd}
(utilities
to add updates to the NEWS.md
file)
{autonewsmd}
(to
auto-generate change log using conventional commits)
{docreview}
(to check
quality of docs)
{spelling}
(to check for
spelling mistakes)
{gramr}
(for grammar
suggestions)
{testthat}
(a testing framework for
R that is easy to learn and use; also provides snapshot testing)
{patrick}
(for
parameterized unit testing with {testthat}
)
{testdat}
(a
family of functions and reporting tools focused on checking of data)
{tinytest}
(zero-dependency unit testing framework that installs tests with the
package)
{tinysnapshot}
(snapshots for unit tests using the
{tinytest}
framework)
{tinytest2JUnit}
(to convert
{tinytest}
output
to JUnit XML needed by CI/CD)
{RUnit}
(a standard
unit testing framework, with additional code inspection and report
generation tools)
{testit}
(a simple
package for testing R packages)
{realtest}
(a
framework unit testing that distinguishes between expected,
acceptable, current, fallback, ideal, or regressive behaviours)
{roxytest}
(to inline
{testthat}
tests with {roxygen2}
)
{doctest}
(to write
{testthat}
tests by adding {roxygen2}
tags)
{exampletestr}
(tests
based on package examples)
{roxut}
(to write the
unit tests in the same file as the function)
{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)
{cucumber}
(an
implementation of the Cucumber testing
framework in R)
{quickcheck}
(provides
property-based testing in {testthat}
framework)
{httptest}
(a test environment
for HTTP requests in R)
{httptest2}
(the same for
{httr2}
package)
{webfakes}
(provides fake web apps
for HTTP testing R packages)
{dittodb}
(makes testing against
databases easy)
{vdiffr}
(for visual regression
testing with {testthat}
)
{gdiff}
(for
performing graphical difference different package or R versions)
{mockthat}
(provides a way to
mock package function for unit testing, while coping with S3
dispatch)
{mockr}
(provides a way to mock
package function for unit testing)
{mockery}
(provides
a way to mock package function for unit testing and can be used with
any testing framework)
{mutant}
(mutation testing for
R){shinytest}
(testing Shiny
apps)
{shinytest2}
(testing
Shiny apps using a headless Chromium web browser)
{shinyloadtest}
(to
load test deployed Shiny apps)
{testthis}
(RStudio
addins for working with files that contain tests)
{xpectr}
(builds unit
tests with the {testthat}
package by providing tools for
generating expectations)
{testdown}
(turn
{testthat}
results into a {bookdown}
project)
{ttdo}
(provides
โdiffโ-style comparison of R objects for {tinytest}
framework)
{styler}
(to format code according to
a style guide)
{stylermd}
(to
format text in Markdown documents)
{formatR}
(to format
R source code)
{RFormatter}
(extension of {formatR}
with slightly improved heuristics)
{grkstyle}
(extension
package for {styler}
that supports authorโs personal code style
preferences)
{codegrip}
(addin for
RStudio IDE to reshape R code and navigate across syntactic
constructs)
{BiocStyle}
(provides standard formatting styles for Bioconductor PDF and HTML
documents)
AlignAssign
(RStudio
addin that aligns the assignment operators within a highlighted
area)
{snakecase}
(helpful for
having consistent case while naming objects in the package)
{dotInternals}
(to distinguish non-exported package functions by prepending their
names with a dot)
{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.)
{PaRe}
(reviews other
packages during code review by looking at their dependencies, code
style, code complexity, and how internally defined functions
interact with one another){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)
{lintr}
(static code analysis)
{roxylint}
(to
lint {roxygen2}
-generated documentation)
{checkglobals}
(to check R-packages for globals and imports)
{CodeDepends}
(analysis
of R code for reproducible research and code view)
{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)
{cyclocomp}
(to
index the complexity of a function)
{pkgGraphR}
(to visualize
the relationship between functions in an R package)
{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)
{memtools}
(to solve memory leaks)
{sanitizers}
(to
test for memory violations and other undefined behaviour)
{cppcheckR}
(to
check C
and C++
code using
Cppcheck
)
{cloc}
(counts blank lines,
comment lines, and physical lines of source code in source files){refactor}
(to
check speed and performance of both the original and refactored
version of code){bench}
(provides high precision
benchmarks for R expressions)
{microbenchmark}
(provides infrastructure to accurately measure and compare the
execution time of R expressions)
{tictoc}
(provides
functions for timing R scripts)
{touchstone}
(benchmarking pull requests)
{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.)
{xrprof}
(an external
sampling profiler for R programs)
{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)
{DependencyReviewer}
(to investigate packages during code review by looking at their
dependencies)
{deps}
(to manage source code
dependencies by decorating R code with roxygen-style comments)
{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)
{rcmdcheck}
(to run R CMD check
form R programmatically)
{BiocCheck}
(to run
Bioconductor-specific package checks)
{rhub}
(to run
R CMD check
on CRAN architectures)
{checkhelper}
(to
help avoid problems with CRAN submissions)
{extrachecks}
(to
run some additional CRAN checks)
{foghorn}
(to check
for results and submission portal status)
{urlchecker}
(to checks
for URL rot)
{cranlogs}
(for computing
CRAN download counts)
{packageRank}
(for
visualizing CRAN download counts)
{dlstats}
(provides
download statistics for packages)
CI/CD: continuous integration and either continuous delivery or continuous deployment
actions
(provides GitHub
Actions relevant for R)
actions-sync
(to manage
GitHub Actions workflows across repositories)
{rworkflows}
(GitHub Actions to automates testing, documentation website
building, and containerized deployment)
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)
{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)
{fakemake}
(to mock
Unix Make build system in case it is unavailable){valtools}
(in clinical
research and drug development){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)
{boomer}
(provides
debugging tools to inspect the intermediate steps of a call)
{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)
{erify}
(to check arguments and
generate readable error messages)
{validate}
(to check
whether data lives up to expectations based on the domain-specific
knowledge)
{codemetar}
(provides
utilities to generate, parse, and modify codemeta.jsonld
files
automatically for R packages), or
{codemeta}
(a leaner
version of {codemetar}
)
{cffr}
(provides utilities to
generate, parse, modify and validate CITATION.cff
files
automatically for R packages)
{citation}
(creates
CITATION.cff
from R package metadata)
{pkgapi}
(to create the map of
function calls in a package)
{riskmetric}
(provides a
collection of risk metrics to evaluate the quality of R packages)
{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)
{revdepcheck}
(for automated,
isolated, reverse dependency checking)
{xfun}
(specifically,
xfun::rev_check()
)
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)
{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)
{TODOr}
(RStudio addin to list
things that you need to do or change){pkglite}
(tools to represent
and exchange R package source code as text files)
{gpttools}
(RStudio
addin that allows using
chatGPT to automate writing
documentation, tests, etc.)
{rfold}
(to work with
many R folders within an R package)
{many}
(to create R
packages from many directories)
{prefixer}
(prefix
function with their namespace )
{options}
(provides simple
mechanisms for defining and interpreting package options)
{onetime}
(for package
authors to run code only once for a given user on a given computer)
{rstudioapi}
(to
conditionally access the RStudio API from CRAN packages)
{rcheology}
(to
access data on base packages for previous versions of R)
{gitignore}
(to
fetch gitignore templates)
{DIZutils}
(helpers
for packages dealing with database connections)
โ Session info โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
setting value
version R version 4.4.0 (2024-04-24)
os Ubuntu 22.04.4 LTS
system x86_64, linux-gnu
ui X11
language (EN)
collate C.UTF-8
ctype C.UTF-8
tz UTC
date 2024-05-12
pandoc 3.2 @ /opt/hostedtoolcache/pandoc/3.2/x64/ (via rmarkdown)
quarto 1.5.33 @ /usr/local/bin/quarto
โ Packages โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
package * version date (UTC) lib source
base * 4.4.0 2024-05-06 [3] local
cli 3.6.2 2023-12-11 [1] RSPM
clipr 0.8.0 2022-02-22 [1] RSPM
compiler 4.4.0 2024-05-06 [3] local
datasets * 4.4.0 2024-05-06 [3] local
desc 1.4.3 2023-12-10 [1] RSPM
details * 0.3.0 2022-03-27 [1] RSPM
digest 0.6.35 2024-03-11 [1] RSPM
evaluate 0.23 2023-11-01 [1] RSPM
fastmap 1.1.1 2023-02-24 [1] RSPM
graphics * 4.4.0 2024-05-06 [3] local
grDevices * 4.4.0 2024-05-06 [3] local
grid 4.4.0 2024-05-06 [3] local
htmltools 0.5.8.1 2024-04-04 [1] RSPM
httr 1.4.7 2023-08-15 [1] RSPM
jsonlite 1.8.8 2023-12-04 [1] RSPM
knitr 1.46 2024-04-06 [1] RSPM
magrittr 2.0.3 2022-03-30 [1] RSPM
methods * 4.4.0 2024-05-06 [3] local
png 0.1-8 2022-11-29 [1] RSPM
R6 2.5.1 2021-08-19 [1] RSPM
rlang 1.1.3 2024-01-10 [1] RSPM
rmarkdown 2.26 2024-03-05 [1] RSPM
sessioninfo 1.2.2.9000 2024-04-28 [1] Github (r-lib/sessioninfo@064bc38)
stats * 4.4.0 2024-05-06 [3] local
tools 4.4.0 2024-05-06 [3] local
utils * 4.4.0 2024-05-06 [3] local
withr 3.0.0 2024-01-16 [1] RSPM
xfun 0.43 2024-03-25 [1] RSPM
xml2 1.3.6 2023-12-04 [1] RSPM
yaml 2.3.8 2023-12-11 [1] RSPM
[1] /home/runner/work/_temp/Library
[2] /opt/R/4.4.0/lib/R/site-library
[3] /opt/R/4.4.0/lib/R/library
* โโ Packages attached to the search path.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ