Resources and Tools for Writing Your Own and Understanding Other People’s R Packages (2025)

R
Programming
Author
Affiliation

Michael S. Truong

York University

Published

September 17, 2025

Writing and understanding R packages can be quite challenging.

To make things easier, I’ve compiled a short list of R libraries that may be helpful for this task.1

1 This is not a comprehensive list, but there doesn’t seem to be a CRAN task view for this sort of thing and I am trying to fill this gap. The closest match might be the “Reproducible Research” CRAN Task View.

2 It’s also worth noting that the packages I cite generally lean towards those actively supported by Posit, specifically under the collection of R packages maintained under “r-lib”. This isn’t necessarily good or bad, but it’s helpful to use software that is actively maintained. The hope is that one will be able to learn the package once, then use it for a long time and in a very productive manner. Also, a highly used package is a highly tested package, which helps make for a good user experience.

I’ve only used a subset of them, but I hope to update this blog post when I figure out whether I can make them live up to my hype.2

General Packages and Resources

  1. rlang

    • This package has many advanced features. In particular, it can help diagnose errors by formatting them into a readable format.

      rlang::global_entrance()
rlang::trace_back()
rlang::try_fetch()
  2. generics
    • Promises to make the UX of your package more similar to other packages, while reducing the number of dependencies.
    • The chief example is letting you write a tidy method, without importing broom.
  3. Comparing R Objects
    1. waldo

      • Colorful and user-friendly comparison of R-objects.

        wald::compare()

      • Contrast with all.equal() and identical()

    2. digest

      • This package is unusual in that it compares objects using hashes.

        digest::digest()

      • I imagine this could be particularly useful in cases of exact numerical comparisons with no tolerance, which may sometimes occur during statistical computing.

  4. lobstr
  5. ellipsis
  6. callr

    • This package helps run R code in a separate process. This might be handy when you’re inside a debugging environment and want to test something.

      callr::r()
  7. evaluate

    • Recreates command line behavior.

      evaluate::parse_all()
evaluate::evaluate()
evaluate::replay()

    • Perhaps this would be helpful to recreate a point in a debugging environment?

  8. devtools
    • Default package for developing R packages.
  9. reprex
    • Must-have for reporting bugs and communicating with other developers.
  10. sessioninfo
    • A must-have for communicating with other developers and comparing environments between machines.
  11. clipr

    • Intermediary between R and your clipboard.

      clipr::write_clip()
clipr::read_clip()

    • Could be helpful when you’re inside a debugging environment.

  12. datapasta
    • Can be used to copy data and try to read into R more easily.
  13. Air
    • Format R code really fast, is not a package.
  14. Writing R extensions
    • Classic.
  15. Advanced R
    • Classic.
  16. R Packages
    • Classic.

Benchmarking

Benchmarking is important for comparing different implementations of the same idea. It can also help with performance tuning.

  1. bench

    • Comparing performance of different functions.

      bench::mark()

  2. profvis

    • Timing specific components of functions.

      profvis::profvis()

  3. proftools

Static Code Analysis

These tools analyze R code without running them. It would probably be better to use these tools rather than trying to manually map out what happens to an R object using pen-and-paper.

  1. lintr

    • Linting your code.

      lintr::lint()

  2. checkglobals

    • See what variables and functions a R source code file uses.

      checkglobals::checkglobals()

  3. codetools

  4. globals

    1. Similar to checkglobals and codetools.

      globals::Globals()

  5. pkgnet

  6. CodeDepends

    • As per the vignette, “the CodeDepends package provides a flexible framework for statically analyzing R code (i.e., without evaluating it). It also contains higher-level functionality for: detecting dependencies between R code blocks or expressions, “tree-shaking” (pruning a script down to only the expressions necessary to evaluate a given expression), plotting variable usage timelines, and more.”

    • See this vignette for more

      CodeDepends::getInputs()
CodeDepends::inputCollector()
CodeDepends::makeCallGraph()
CodeDepends::makeTaskGraph()
CodeDepends::makeVariableGraph()
CodeDepends::getDetailedTimelines()

  7. flowr

    • As per the associated master thesis’ abstract, “In this master thesis we describe the construction of a backward program slicer for the R programming language. Given a variable at a specific point in the program, a so-called”slicing criterion”, the slicer returns the subset of the program that might affect the value of the variable.”

    • Interfaces with the external program flowr.

    • This seems rather sophisticated and actively developed, rather than describe it very inaccurately, it would be better for me to link to its Wiki and the associated master thesis.

Tests

Tests are important for making sure that your code really does what it’s supposed to do. There’s also the popular philosophy of ‘test driven development’, which can help guide the development of your package based on some clear criteria, meaning tests.

  1. covr

  2. testthat

    • Default testing package.

  3. unittest

  4. unitizer

    • This is like an interactive testthat that can write to your filesystem. See this recording.

    • As per the package vignette, the package “unitizer requires you to review test outputs and confirm they are as expected. [In contrast, the package] testthat requires you to assert what the test outputs should be beforehand.”

      unitizer::unitize()
demo(package = "unitizer")
browseVignettes("unitizer")

  5. RUnit

    • A testing package inspired by JUnit.

    • A notable feature seems to be the ability to track the value of a variable.

    • It apparently changes the random number generation. See this vignette for more information.

      RUnit::tracker()
RUnit::inspect()

  6. tinytest

    • Seems similar in purpose to unittest and similar in usage to testthat.

Debugging

Debugging is helpful when something has gone wrong/unexpected.

  1. debugme

    • Lets you use strings to initialize debugging debugging, instead of debug(). Initialization depends on the system environment variable DEBUGME.

    • Inspired by npm’s debug package.

      "!DEBUG Start up shiny"
debugme::debugme()

General Resources on debugging in R:

C/C++ and Memory Leaks

When using C/C++, in particular, these utilities may be useful:

  1. lldb

  2. valgrind

  3. gdb

  4. memtools :

    • Something about memory leaks and analyzing memory in R.

    • Does not seem to be supported on R 4.6 as of April 29/2026

      memtools::mem_snapshot()
memtools::mem_igraph()
memtools::root_ns_registry()
memtools::mem_stash()
memtools::obj_address()
memtools::mem_paths_shortest()

Logging

Generally, logging in R can be used to store the output of a script. For our purposes, it can be helpful for selectively understanding the state and development of an R object(s) over time–then storing this output in a human-readable format.

This can be better than manually tracking an R object(s) and making mental notes of what happens to it.

  1. log4r

  2. logger

    • Inspired by the futile.logger R package and Python’s logging.

      logger::log_info()
logger::log_warn()
logger::log_debug()
logger::log_formatter()

    • This seems to overlap substantially with log4r.

  3. lumberjack

  4. logrx

    • A quick glance seems to make this out to be a logger that doesn’t require as much manual fiddling of what to log.

      logrx::axecute()

    • This also seems to be part of the pharmaverse series of packages.

  5. tidylog

    • Logging that is specific to dplyr and tidyr.

  6. logr

    • An easy logger. Presumably similar to logrx, in purpose, but is supposed to be familiar to SAS users.

      options(
  "logr.autolog" = TRUE,
  "logr.on" = TRUE,
  "logr.notes" = TRUE,
  "logr.compact" = TRUE,
  "logr.traceback" = TRUE,
  "logr.stdout" = TRUE,
  "logr.linesize" = 100
)
logr::log_open()
logr::log_code()
logr:::sep()
logr::log_print()
logr::log_close()

    • See the available options here.

  7. whirl

    1. As I copy pasted from the whirl Overview:

      “The whirl package provide functionalities for executing scripts in batch and simultaneously getting a log from the individual executions. A log from script execution is in many pharmaceutical companies a GxP requirement, and the whirl package honors this requirement by generating a log that, among other things, contains information about:

      • Status (did the script run with any error or warnings)
      • The actual code itself
      • Date and time of execution
      • The environment the script was executed under (session info)
      • Information about packages versions that was utilized
      • Environmental variables

      And all this is wrapped into a nicely formatted html document that is easy to navigate.”

      whirl::run()

Printing to Command Line

  1. crayon

    • Formats R terminal output in pretty ways.

  2. cli

    • Good looking terminal output.

  3. prettyunits

    • Good looking printing of units.

  4. pillar

    • Good looking printing of columns.

Blog Post Computational Environment

Warning in utils::citation(pkg_name): could not determine year for 'flowr' from
package DESCRIPTION file

We used R v. 4.6.1 (R Core Team 2026) and the following R packages: bench v. 1.1.4 (Hester and Vaughan 2025), callr v. 3.7.6 (Csárdi and Chang 2024), checkglobals v. 0.1.4 (Chau 2025), clipr v. 0.8.0 (Lincoln 2022), CodeDepends v. 0.6.7 (Lang et al. 2026), codetools v. 0.2.20 (Tierney 2024), covr v. 3.6.5 (Hester 2025), crayon v. 1.5.3 (Csárdi 2024a), datapasta v. 3.1.0 (McBain et al. 2020), debugme v. 1.2.0 (Csárdi 2024b), devtools v. 2.5.1 (Wickham et al. 2026), digest v. 0.6.39 (Eddelbuettel 2025), ellipsis v. 0.3.3 (Wickham 2026a), evaluate v. 1.0.5 (Wickham and Xie 2025), flowr v. 0.0.3 (Sihler, n.d.), generics v. 0.1.4 (Wickham, Kuhn, et al. 2025), globals v. 0.19.1 (Bengtsson 2026), lintr v. 3.3.0.1 (Hester et al. 2025), lobstr v. 1.2.1 (Wickham 2026b), log4r v. 0.4.4 (White and Jacobs 2024), logger v. 0.4.1 (Daróczi and Wickham 2025), logr v. 1.3.9 (Bosak 2025), logrx v. 0.4.0 (Kosiba et al. 2025), lumberjack v. 1.3.1 (van der Loo 2021), pkgnet v. 0.6.0 (Burns et al. 2026), prettyunits v. 1.2.0 (Csardi 2023), proftools v. 0.99.3 (Tierney and Jarjour 2020), profvis v. 0.4.0 (Wickham et al. 2024), rmarkdown v. 2.31 (Xie et al. 2018, 2020; Allaire et al. 2026), RUnit v. 0.4.33.1 (Burger et al. 2025), sessioninfo v. 1.2.3 (Wickham, Chang, et al. 2025), testthat v. 3.3.2 (Wickham 2011), tidylog v. 1.1.0 (Elbers 2024), tidyverse v. 2.0.0 (Wickham et al. 2019), tinytest v. 1.4.3 (van der Loo 2020), unitizer v. 1.4.23 (Gaslam 2025), unittest v. 1.7.0 (Lentin and Hennessey 2024), waldo v. 0.6.2 (Wickham 2025), whirl v. 0.3.2 (Thomsen et al. 2026).

═ Session info ═══════════════════════════════════════════════════════════════
─ Packages ───────────────────────────────────────────────────────────────────
 ! package      * version   date (UTC) lib source
 P assertthat     0.2.1     2019-03-21 [?] RSPM
 P backports      1.5.1     2026-04-03 [?] RSPM
 P bench        * 1.1.4     2025-01-16 [?] RSPM
 P BiocGenerics   0.56.0    2025-10-29 [?] Bioconduc~
 P BiocManager    1.30.27   2025-11-14 [?] RSPM
 P brio           1.1.5     2024-04-24 [?] RSPM
 P cachem         1.1.0     2024-05-16 [?] RSPM
 P callr        * 3.7.6     2024-03-25 [?] RSPM
 P checkglobals * 0.1.4     2025-10-01 [?] RSPM
 P cli          * 3.6.6     2026-04-09 [?] RSPM
 P clipr        * 0.8.0     2022-02-22 [?] RSPM
 P clisymbols     1.2.0     2017-05-21 [?] RSPM
 P CodeDepends  * 0.6.7     2026-03-03 [?] RSPM
 P codetools    * 0.2-20    2024-03-31 [?] CRAN (R 4.6.0)
 P common       * 1.1.5     2026-02-23 [?] RSPM
 P covr         * 3.6.5     2025-11-09 [?] RSPM
 P crayon       * 1.5.3     2024-06-20 [?] RSPM
 P data.table     1.18.2.1  2026-01-27 [?] RSPM
 P datapasta    * 3.1.0     2020-01-17 [?] RSPM
 P debugme      * 1.2.0     2024-04-25 [?] RSPM
 P devtools     * 2.5.1     2026-04-16 [?] RSPM
 P diffobj        0.3.6     2025-04-21 [?] RSPM
 P digest       * 0.6.39    2025-11-19 [?] RSPM
 P dplyr          1.2.1     2026-04-03 [?] RSPM
 P DT             0.34.0    2025-09-02 [?] RSPM
 P ellipsis     * 0.3.3     2026-04-04 [?] RSPM
 P evaluate     * 1.0.5     2025-08-27 [?] RSPM
 P fastmap        1.2.0     2024-05-15 [?] RSPM
 P flowr        * 0.0.3     2026-04-29 [?] Github (flowr-analysis/flowr-r-adapter@b171729)
 P fs             2.1.0     2026-04-18 [?] RSPM
 P generics     * 0.1.4     2025-05-09 [?] RSPM (R 4.6.0)
 P globals      * 0.19.1    2026-03-13 [?] RSPM
 P glue           1.8.1     2026-04-17 [?] RSPM
 P graph          1.88.1    2025-12-08 [?] Bioconduc~
 P grateful     * 0.3.0     2025-09-04 [?] RSPM
 P htmltools      0.5.9     2025-12-04 [?] RSPM
 P htmlwidgets    1.6.4     2023-12-06 [?] RSPM
 P httr           1.4.8     2026-02-13 [?] RSPM
 P igraph         2.3.0     2026-04-21 [?] RSPM
 P jsonlite       2.0.0     2025-03-27 [?] RSPM
 P knitr          1.51      2025-12-20 [?] RSPM
 P lattice        0.22-9    2026-02-09 [?] CRAN (R 4.6.1)
 P lifecycle      1.0.5     2026-01-08 [?] RSPM
 P lintr        * 3.3.0-1   2025-11-27 [?] RSPM
 P lobstr       * 1.2.1     2026-04-04 [?] RSPM
 P log4r        * 0.4.4     2024-10-12 [?] RSPM
 P logger       * 0.4.1     2025-09-11 [?] RSPM
 P logr         * 1.3.9     2025-03-26 [?] RSPM
 P logrx        * 0.4.0     2025-05-05 [?] RSPM
 P lumberjack   * 1.3.1     2023-03-29 [?] RSPM
 P magrittr       2.0.5     2026-04-04 [?] RSPM
 P Matrix         1.7-5     2026-03-21 [?] CRAN (R 4.6.1)
 P memoise        2.0.1     2021-11-26 [?] RSPM
 P otel           0.2.0     2025-08-29 [?] RSPM
 P pillar       * 1.11.1    2025-09-17 [?] RSPM
 P pkgbuild       1.4.8     2025-05-26 [?] RSPM
 P pkgconfig      2.0.3     2019-09-22 [?] RSPM
 P pkgload        1.5.2     2026-04-22 [?] RSPM
 P pkgnet       * 0.6.0     2026-01-27 [?] RSPM
 P png            0.1-9     2026-03-15 [?] RSPM
 P prettyunits  * 1.2.0     2023-09-24 [?] RSPM
 P processx       3.9.0     2026-04-22 [?] RSPM
 P proftools    * 0.99-3    2020-07-08 [?] RSPM
 P profvis      * 0.4.0     2024-09-20 [?] RSPM
 P ps             1.9.3     2026-04-20 [?] RSPM
 P purrr          1.2.2     2026-04-10 [?] RSPM
 P R6             2.6.1     2025-02-15 [?] RSPM
 P Rcpp           1.1.1-1.1 2026-04-24 [?] RSPM
 P renv           1.2.2     2026-04-16 [?] RSPM
 P reprex       * 2.1.1     2024-07-06 [?] RSPM
 P reticulate     1.46.0    2026-04-09 [?] RSPM
 P rex            1.2.2     2026-03-28 [?] RSPM
 P rlang        * 1.2.0     2026-04-06 [?] RSPM
 P rmarkdown      2.31      2026-03-26 [?] RSPM
 P RUnit        * 0.4.33.1  2025-06-17 [?] RSPM
 P sessioninfo  * 1.2.3     2025-02-05 [?] RSPM
 P stringi        1.8.7     2025-03-27 [?] RSPM
 P stringr        1.6.0     2025-11-04 [?] RSPM
 P testthat     * 3.3.2     2026-01-11 [?] RSPM
 P tibble         3.3.1     2026-01-11 [?] RSPM
 P tidylog      * 1.1.0     2024-05-08 [?] RSPM
 P tidyr          1.3.2     2025-12-19 [?] RSPM
 P tidyselect     1.2.1     2024-03-11 [?] RSPM
 P tinytest     * 1.4.3     2026-03-24 [?] RSPM
 P unitizer     * 1.4.23    2025-10-22 [?] RSPM
 P unittest     * 1.7-0     2024-08-16 [?] RSPM
 P usethis      * 3.2.1     2025-09-06 [?] RSPM
 P vctrs          0.7.3     2026-04-11 [?] RSPM
 P visNetwork     2.1.4     2025-09-04 [?] RSPM
 P waldo        * 0.6.2     2025-07-11 [?] RSPM
 P whirl        * 0.3.2     2026-01-21 [?] RSPM
 P withr          3.0.2     2024-10-28 [?] RSPM
 P xfun           0.57      2026-03-20 [?] RSPM
 P XML            3.99-0.23 2026-03-20 [?] RSPM
 P xml2           1.5.2     2026-01-17 [?] RSPM
 P yaml           2.3.12    2025-12-10 [?] RSPM

 [1] /home/mstruong/Documents/RStudio/website/emstruong.github.io/renv/library/linux-ubuntu-jammy/R-4.6/x86_64-pc-linux-gnu
 [2] /home/mstruong/.cache/R/renv/sandbox/linux-ubuntu-jammy/R-4.6/x86_64-pc-linux-gnu/e7c0fad7

 * ── Packages attached to the search path.
 P ── Loaded and on-disk path mismatch.

──────────────────────────────────────────────────────────────────────────────

References

Allaire, JJ, Yihui Xie, Christophe Dervieux, et al. 2026. rmarkdown: Dynamic Documents for r. https://github.com/rstudio/rmarkdown.
Bengtsson, Henrik. 2026. globals: Identify Global Objects in r Expressions. https://globals.futureverse.org.
Bosak, David. 2025. logr: Creates Log Files. https://logr.r-sassy.org.
Burger, Matthias, Klaus Juenemann, and Thomas Koenig. 2025. RUnit: R Unit Test Framework.
Burns, Brian, James Lamb, and Jay Qi. 2026. pkgnet: Get Network Representation of an r Package. https://github.com/uptake/pkgnet.
Chau, Joris. 2025. checkglobals: Static Analysis of r-Code Dependencies. https://jorischau.github.io/checkglobals/.
Csardi, Gabor. 2023. prettyunits: Pretty, Human Readable Formatting of Quantities. https://github.com/r-lib/prettyunits.
Csárdi, Gábor. 2024a. crayon: Colored Terminal Output. https://r-lib.github.io/crayon/.
Csárdi, Gábor. 2024b. debugme: Debug r Packages. https://github.com/r-lib/debugme#readme.
Csárdi, Gábor, and Winston Chang. 2024. callr: Call r from r. https://callr.r-lib.org.
Daróczi, Gergely, and Hadley Wickham. 2025. logger: A Lightweight, Modern and Flexible Logging Utility. https://daroczig.github.io/logger/.
Eddelbuettel, Dirk. 2025. digest: Create Compact Hash Digests of r Objects. https://doi.org/10.32614/CRAN.package.digest.
Elbers, Benjamin. 2024. tidylog: Logging for “dplyr” and “tidyr” Functions. https://github.com/elbersb/tidylog/.
Gaslam, Brodie. 2025. unitizer: Interactive r Unit Tests. https://github.com/brodieG/unitizer.
Hester, Jim. 2025. covr: Test Coverage for Packages. https://covr.r-lib.org.
Hester, Jim, Florent Angly, Michael Chirico, et al. 2025. “Static Code Analysis for r.” Journal of Open Source Software 10 (108): 7240. https://doi.org/10.21105/joss.07240.
Hester, Jim, and Davis Vaughan. 2025. bench: High Precision Timing of r Expressions. https://bench.r-lib.org/.
Kosiba, Nathan, Thomas Bermudez, Ben Straub, Michael Rimler, Nicholas Masel, and Sam Parmar. 2025. logrx: A Logging Utility Focus on Clinical Trial Programming Workflows. https://pharmaverse.github.io/logrx/.
Lang, Duncan Temple, Roger Peng, Deborah Nolan, and Gabriel Becker. 2026. CodeDepends: Analysis of r Code for Reproducible Research and Code Comprehension. https://github.com/duncantl/CodeDepends.
Lentin, Jamie, and Anthony Hennessey. 2024. unittest: TAP-Compliant Unit Testing.
Lincoln, Matthew. 2022. clipr: Read and Write from the System Clipboard. https://github.com/mdlincoln/clipr.
McBain, Miles, Jonathan Carroll, Sharla Gelfand, Suthira Owlarn, and Garrick Aden-Buie. 2020. datapasta: R Tools for Data Copy-Pasta. https://github.com/milesmcbain/datapasta.
R Core Team. 2026. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing. https://doi.org/10.32614/R.manuals.
Sihler, Florian. n.d. flowr: flowR r Adapter. https://github.com/flowr-analysis/flowr-r-adapter.
Thomsen, Aksel, Lovemore Gakava, Cervan Girard, et al. 2026. whirl: Log Execution of Scripts. https://novonordisk-opensource.github.io/whirl/.
Tierney, Luke. 2024. codetools: Code Analysis Tools for r. https://doi.org/10.32614/CRAN.package.codetools.
Tierney, Luke, and Riad Jarjour. 2020. proftools: Profile Output Processing Tools for r.
van der Loo, Mark P. J. 2021. “Monitoring Data in R with the lumberjack Package.” Journal of Statistical Software 98 (1): 1–13. https://doi.org/10.18637/jss.v098.i01.
van der Loo, MPJ. 2020. “A Method for Deriving Information from Running r Code.” The R Journal 13: 42–52. https://journal.r-project.org/articles/RJ-2021-056/.
White, John Myles, and Aaron Jacobs. 2024. Log4r: A Fast and Lightweight Logging System for r, Based on “log4j”. https://github.com/johnmyleswhite/log4r.
Wickham, Hadley. 2011. “testthat: Get Started with Testing.” The R Journal 3: 5–10. https://journal.r-project.org/articles/RJ-2011-002/.
Wickham, Hadley. 2025. waldo: Find Differences Between r Objects. https://waldo.r-lib.org.
Wickham, Hadley. 2026a. ellipsis: Tools for Working with ... https://ellipsis.r-lib.org.
Wickham, Hadley. 2026b. lobstr: Visualize r Data Structures with Trees. https://lobstr.r-lib.org/.
Wickham, Hadley, Mara Averick, Jennifer Bryan, et al. 2019. “Welcome to the tidyverse.” Journal of Open Source Software 4 (43): 1686. https://doi.org/10.21105/joss.01686.
Wickham, Hadley, Winston Chang, Robert Flight, Kirill Müller, and Jim Hester. 2025. sessioninfo: R Session Information. https://github.com/r-lib/sessioninfo#readme.
Wickham, Hadley, Winston Chang, Javier Luraschi, and Timothy Mastny. 2024. profvis: Interactive Visualizations for Profiling r Code. https://profvis.r-lib.org.
Wickham, Hadley, Jim Hester, Winston Chang, and Jennifer Bryan. 2026. devtools: Tools to Make Developing r Packages Easier. https://devtools.r-lib.org/.
Wickham, Hadley, Max Kuhn, and Davis Vaughan. 2025. generics: Common S3 Generics Not Provided by Base r Methods Related to Model Fitting. https://generics.r-lib.org.
Wickham, Hadley, and Yihui Xie. 2025. evaluate: Parsing and Evaluation Tools That Provide More Details Than the Default. https://evaluate.r-lib.org/.
Xie, Yihui, J. J. Allaire, and Garrett Grolemund. 2018. R Markdown: The Definitive Guide. Chapman; Hall/CRC. https://yihui.org/rmarkdown/.
Xie, Yihui, Christophe Dervieux, and Emily Riederer. 2020. R Markdown Cookbook. Chapman; Hall/CRC. https://yihui.org/rmarkdown-cookbook.

Reuse

Citation

BibTeX citation:
@online{truong2025,
  author = {Truong, Michael S.},
  title = {Resources and {Tools} for {Writing} {Your} {Own} and
    {Understanding} {Other} {People’s} {R} {Packages} (2025)},
  date = {2025-09-17},
  langid = {en}
}
For attribution, please cite this work as:
Truong, Michael S. 2025. “Resources and Tools for Writing Your Own and Understanding Other People’s R Packages (2025).” September 17.