Skip to content
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
Cannot retrieve contributors at this time
- building.html
# Packaging Guide {#building}
```{block, type="summaryblock"}
rOpenSci accepts packages that meet our guidelines via a streamlined [Software Peer Review process](#whatissoftwarereview). To ensure a consistent style across all of our tools we have written this chapter highlighting our guidelines for package development. Please also read and apply our [chapter about continuous integration (CI)](#ci). Further guidance for after the review process is provided in the third section of this book starting with [a chapter about collaboration](#collaboration).
We strongly recommend that package developers read Hadley Wickham and Jenny Bryan's concise but thorough book on package development which is available for [free online]( Our guide is partially redundant with other resources but highlights rOpenSci's guidelines.
To read why submitting a package to rOpenSci is worth the effort to meet guidelines, have a look at [reasons to submit](#whysubmit).
## Package name and metadata {#package-name-and-metadata}
### Naming your package {#naming-your-package}
* We strongly recommend short, descriptive names in lower case. If your package deals with one or more commercial services, please make sure the name does not violate branding guidelines. You can check if your package name is available, informative and not offensive by using the [`available` package]( In particular, do _not_ choose a package name that's already used on CRAN or Bioconductor.
* There is a trade-off between the advantages of a unique package name and a less original package name.
- A more unique package name might be easier to track (for you and us to assess package use for instance, less false positives when typing its name in GitHub code search) and search (for users to ask "how to use package blah" in a search engine).
- On the other hand a _too_ unique package name might make the package less discoverable (that is to say, to find it by searching "how to do this-thing in R"). It might be an argument for naming your package something very close to its topic such as [geojson](
- Find other interesting aspects of naming your package [in this blog post by Nick Tierney](, and in case you change your mind, find out [how to rename your package in this other blog post of Nick's](
### Creating metadata for your package {#creating-metadata-for-your-package}
We recommend you to use the [`codemetar` package]( for creating and updating a JSON [CodeMeta]( metadata file for your package via `codemetar::write_codemeta()`. It will automatically include all useful information, including [GitHub topics](#grooming). CodeMeta uses [ terms]( so as it gains popularity the JSON metadata of your package might be used by third-party services, maybe even search engines.
## Platforms {#platforms}
- Packages should run on all major platforms (Windows, macOS, Linux). Exceptions may be granted packages that interact with system-specific functions, or wrappers for utilities that only operate on limited platforms, but authors should make every effort for cross-platform compatibility, including system-specific compilation, or containerization of external utilities.
## Package API {#package-api}
### Function and argument naming {#function-and-argument-naming}
- Functions and arguments naming should be chosen to work together to form a common, logical programming API that is easy to read, and auto-complete.
- Consider an `object_verb()` naming scheme for functions in your package that take a common data type or interact with a common API. `object` refers to the data/API and `verb` the primary action. This scheme helps avoid namespace conflicts with packages that may have similar verbs, and makes code readable and easy to auto-complete. For instance, in **stringi**, functions starting with `stri_` manipulate strings (`stri_join()`, `stri_sort()`, and in **googlesheets** functions starting with `gs_` are calls to the Google Sheets API (`gs_auth()`, `gs_user()`, `gs_download()`).
- For functions that manipulate an object/data and return an object/data of the same type, make the object/data the first argument of the function so as to enhance compatibility with the pipe operator (`%>%`).
- We strongly recommend `snake_case` over all other styles unless you are porting over a package that is already in wide use.
- Avoid function name conflicts with base packages or other popular ones (e.g. `ggplot2`, `dplyr`, `magrittr`, `data.table`)
- Argument naming and order should be consistent across functions that use similar inputs.
- Package functions importing data should not import data to the global environment, but instead must return objects. Assignments to the global environment are to be avoided in general.
### Console messages {#console-messages}
- Use `message()` and `warning()` to communicate with the user in your functions. Please do not use `print()` or `cat()` unless it's for a `print.*()` or `str.*()` methods, as these methods of printing messages are harder for the user to suppress.
### Interactive/Graphical Interfaces {#interactive-graphical-interfaces}
If providing graphical user interface (GUI) (such as a Shiny app), to facilitate workflow, include a mechanism to automatically reproduce steps taken in the GUI. This could include auto-generation of code to reproduce the same outcomes, output of intermediate values produced in the interactive tool, or simply clear and well-documented mapping between GUI actions and scripted functions. (See also ["Testing"](#testing) below.)
The [`tabulizer` package]( e.g. has an interactive workflow to extract tables, but can also only extract coordinates so one can re-run things as a script. Besides, two examples of shiny apps that do code generation are [](, and [](
## Code Style {#code-style}
- For more information on how to style your code, name functions, and R scripts inside the `R/` folder, we recommend reading the [code chapter in The R Packages book]( We recommend the [`styler` package]( for automating part of the code styling. We suggest reading the [Tidyverse style guide](
- You can choose to use `=` over `<-` as long you are consistent with one choice within your package. We recommend avoiding the use of `->` for assignment within a package. If you do use `<-` throughout your package, and you also use `R6` in that package, you'll be forced to use `=` for assignment within your `R6Class` construction - this is not considered an inconsistency because you can't use `<-` in this case.
## CITATION file {#citation-file}
- If your package does not yet have a CITATION file, you can create one with `usethis::use_citation()`, and populate it with values generated by the `citation()` function.
- CRAN requires CITATION files to be declared as [`bibentry` items](, and not in the previously-accepted form of [`citEntry()`](
- If you archive each release of your GitHub repo on Zenodo, add the [Zenodo top-level DOI]( to the CITATION file.
- If one day [**after** review at rOpenSci](#authors-guide) you publish a software publication about your package, add it to the CITATION file.
- Less related to your package itself but to what supports it: if your package wraps a particular resource such as data source or, say, statistical algorithm, remind users of how to cite that resource via e.g. `citHeader()`. [Maybe even add the reference for the resource](
As an example see [the dynamite CITATION file]( which refers to the R manual as well as other associated publications.
citHeader("To cite dynamite in publications use:")
key = "dynamitepaper",
bibtype = "Misc",
doi = "10.48550/ARXIV.2302.01607",
url = "",
author = c(person("Santtu", "Tikka"), person("Jouni", "Helske")),
title = "dynamite: An R Package for Dynamic Multivariate Panel Models",
publisher = "arXiv",
year = "2023"
key = "dmpmpaper",
bibtype = "Misc",
title = "Estimating Causal Effects from Panel Data with Dynamic
Multivariate Panel Models",
author = c(person("Santtu", "Tikka"), person("Jouni", "Helske")),
publisher = "SocArxiv",
year = "2022",
url = ""
key = "dynamite",
bibtype = "Manual",
title = "Bayesian Modeling and Causal Inference for Multivariate
Longitudinal Data",
author = c(person("Santtu", "Tikka"), person("Jouni", "Helske")),
note = "R package version 1.0.0",
year = "2022",
url = ""
- You could also create and store a `CITATION.cff` thanks to the [cffr package]( It also provides a [GitHub Action workflow]( to keep the `CITATION.cff` file up-to-date.
## README {#readme}
- All packages should have a README file, named ``, in the root of the repository. The README should include, from top to bottom:
- The package name.
- Badges for continuous integration and test coverage, the badge for rOpenSci peer-review once it has started (see below), a badge, and any other badges (e.g. [R-universe]( If the README has many more badges, you might want to consider using a table for badges, see [this example](, [that one]( and [that one]( Such a table should be more wide than high.
- Short description of goals of package, with descriptive links to all vignettes (rendered, i.e. readable, cf [the documentation website section](#website)) unless the package is small and there's only one vignette repeating the README.
- Installation instructions using e.g. the [remotes package](, [pak package](, or [R-universe](
- Any additional setup required (authentication tokens, etc).
- Brief demonstration usage.
- If applicable, how the package compares to other similar packages and/or how it relates to other packages.
- Citation information i.e. Direct users to the preferred citation in the README by adding boilerplate text "here's how to cite my package". See e.g. [ecmwfr README](
If you use another repo status badge such as a [lifecycle]( badge, please also add a []( badge. [Example of a repo README with two repo status badges](
- Once you have submitted a package and it has passed editor checks, add a peer-review badge via
where issue\_id is the number of the issue in the software-review repository. For instance, the badge for [`rtimicropem`]( review uses the number 126 since it's the [review issue number]( The badge will first indicated "under review" and then "peer-reviewed" once your package has been onboarded (issue labelled "approved" and closed), and will link to the review issue.
- If your README has many badges consider ordering them in an html table to make it easier for newcomers to gather information at a glance. See examples in [`drake` repo]( and in [`qualtRics` repo]( Possible sections are
- Development (CI statuses cf [CI chapter](#ci), Slack channel for discussion, repostatus)
- Release/Published ([CRAN version and release date badges from METACRAN](, [CRAN checks API badge](, Zenodo badge)
- Stats/Usage (downloads e.g. [download badges from METACRAN](
The table should be more wide than it is long in order to mask the rest of the README.
- If your package connects to a data source or online service, or wraps other software, consider that your package README may be the first point of entry for users. It should provide enough information for users to understand the nature of the data, service, or software, and provide links to other relevant data and documentation. For instance,
a README should not merely read, "Provides access to GooberDB," but also include,
"..., an online repository of Goober sightings in South America. More
information about GooberDB, and documentation of database structure and metadata
can be found at *link*".
- We recommend not creating `` directly, but from a `README.Rmd` file (an R Markdown file) if you have any demonstration code. The advantage of the `.Rmd` file is you can combine text with code that can be easily updated whenever your package is updated.
- Consider using `usethis::use_readme_rmd()` to get a template for a `README.Rmd` file and to automatically set up a pre-commit hook to ensure that `` is always newer than `README.Rmd`.
- Extensive examples should be kept for a vignette. If you want to make the vignettes more accessible before installing the package, we suggest [creating a website for your package](#website).
- Add a [code of conduct and contribution guidelines](#friendlyfiles).
- See the [`gistr` README]( for a good example README to follow for a small package, and [`bowerbird` README]( for a good example README for a larger package.
## Documentation {#documentation}
### General {#docs-general}
- All exported package functions should be fully documented with examples.
- If there is potential overlap or confusion with other packages providing similar functionality or having a similar name, add a note in the README, main vignette and potentially the Description field of DESCRIPTION. Examples in [rtweet README](, [rebird README](, and the non-rOpensci package [slurmR](
- The package should contain top-level documentation for `?foobar`, (or ``?`foobar-package` `` if there is a naming conflict). Optionally, you can use both `?foobar` and ``?`foobar-package` `` for the package level manual file, using `@aliases` roxygen tag. `usethis::use_package_doc()` adds the template for the top-level documentation.
- The package should contain at least one **HTML** vignette providing a substantial coverage of package functions, illustrating realistic use cases and how functions are intended to interact. If the package is small, the vignette and the README may have very similar content.
- As is the case for a README, top-level documentation or vignettes may be the first point of entry for users. If your package connects to a data source or online service, or wraps other software, it should provide enough information for users to understand the nature of the data, service, or software, and provide links to other relevant data and documentation. For instance, a vignette intro or documentation should not merely read, "Provides access to GooberDB," but also include, "..., an online repository of Goober sightings in South America. More information about GooberDB, and documentation of database structure and metadata can be found at *link*". Any vignette should outline prerequisite knowledge to be able to understand the vignette upfront.
The general vignette should present a series of examples progressing in complexity from basic to advanced usage.
- Functionality likely to be used by only more advanced users or developers might be better put in a separate vignette (e.g. programming/NSE with dplyr).
- The README, the top-level package docs, vignettes, websites, etc., should all have enough information at the beginning to get a high-level overview of the package and the services/data it connects to, and provide navigation to other relevant pieces of documentation. This is to follow the principle of *multiple points of entry* i.e. to take into account the fact that any piece of documentation may be the first encounter the user has with the package and/or the tool/data it wraps.
- The vignette(s) should include citations to software and papers where appropriate.
- If your package provides access to a data source, we require that DESCRIPTION contains both (1) A brief identification and/or description of the organisation responsible for issuing data; and (2) The URL linking to public-facing page providing, describing, or enabling data access (which may often differ from URL leading directly to data source).
- Only use package startup messages when necessary (function masking for instance). Avoid package startup messages like "This is foobar 2.4-0" or citation guidance because they can be annoying to the user. Rely on documentation for such guidance.
- You can choose to have a README section about use cases of your package (other packages, blog posts, etc.), [example](
### roxygen2 use {#roxygen-2-use}
- We request all submissions to use `roxygen2` for documentation. `roxygen2` is [an R package]( that automatically compiles `.Rd` files to your `man` folder in your package from simple tags written above each function.
- More information on using roxygen2 [documentation]( is available in the R packages book.
- If you were writing Rd by hand, the [Rd2roxygen]( package contains functions to convert Rd to roxygen documentation.
- One key advantage of using `roxygen2` is that your `NAMESPACE` will always be automatically generated and up to date.
- All functions should document the type of object returned under the `@return` heading.
- The default value for each parameter should be clearly documented. For example, instead of writing `A logical value determining if ...`, you should write ``A logical value (default `TRUE`) determining if ...``. It is also good practice to indicate the default values directly in your function definition:
```{r, eval=FALSE}
f <- function(a = TRUE) {
# function code
- Documentation should support user navigation by including useful cross-links between related functions and documenting related functions together in groups or in common help pages. The `@seealso` and `@family` tags (the latter of which automatically creates "See also" links and [can help group]( functions together on pkgdown sites), are recommended for this purpose. See [the "manual" section of The R Packages book]( and [the "function grouping" section of the present chapter](#function-grouping) for more details.
- You could re-use documentation pieces (e.g. details about authentication, related packages) across the vignettes/README/man pages. A possible approach for that is the use of [R Markdown fragments, relying on knitr use of child documents so you can store the re-used parts in a folder in man/, and call them from both the README and the vignette]( as well [as in man pages by using the `@includeRmd` tag available from `roxygen 0.7.0`](
- Add `#' @noRd` to internal functions.
- If you prefer not to clutter up code with extensive documentation, you can place further examples outside of the R script and use the `@example` tag; and you place further documentation in files in a `man-roxygen` folder in the root of your package, and those will be combined into the manual file by the use of `@template <file name>`, for example.
- Put any documentation for an object in a `.R` file in the `man-roxygen` folder (at the root of your package). For example, [this file]( Link to that template file from your function ([e.g.]( with the `@template` keyword ([e.g.]( The contents of the template will be inserted when documentation is built into the resulting `.Rd` file that users will see when they ask for documentation for the function.
- Note that if you are using markdown documentation, markdown currently doesn't work in template files, so make sure to use latex formatting.
- In most cases you can ignore templates and `man-roxygen`, but there are two cases in which leveraging them will greatly help:
1. When you have a lot of documentation for a function/class/object separating out certain chunks of that documentation can keep your `.R` source file tidy. This is especially useful when you have a lot of code in that `.R` file. On the other hand, it means the docs are not readable "in-source" since they're in another file.
2. When you have the same documentation parts used across many `.R` functions it's helpful to use a template. This reduces duplicated text, and helps prevent mistakenly updating documentation for one function but not the other. Using a template file for a parameter documentation is an alternative to defining the parameter for one function and using `@inheritParams` for other functions using the same parameter.
- Starting from `roxygen2` version 7.0.0, `R6` classes are officially supported. See the [roxygen2 docs]( for details on how to document `R6` classes.
### URLs in documentation {#ur-ls-in-documentation}
This subsection is particularly relevant to authors wishing to submit their package to CRAN.
CRAN will check URLs in your documentation and does not allow redirect status codes such as 301.
You can use the [urlchecker]( package to reproduce these checks and, in particular, replace URLs with the URLs they redirect to.
Others have used the option to escape some URLs (change `<>` to ``, or `\url{}` to ``.), but if you do so, you will need to implement some sort of URL checking yourself to prevent them from getting broken without your noticing. Furthermore, links would not be clickable from local docs.
## Documentation website {#website}
We recommend creating a documentation website for your package using [`pkgdown`]( Neal Richardson wrote [a good tutorial to get started with `pkgdown`](, and unsurprisingly `pkgdown` has [its own documentation website](
There are a few elements we'd like to underline here.
### Automatic deployment of the documentation website {#docsropensci}
You only need to worry about automatic deployment of your website until approval and transfer of your package repo to the ropensci organization; indeed, after that a pkgdown website will be built for your package after each push to the GitHub repo. You can find the status of these builds at ``, e.g. [for `magick`](; and the website at ``, e.g. [for `magick`]( The website build will use your pkgdown config file if you have one, except for the styling that will use the [`rotemplate` package]( The resulting website will have a local search bar. Please report bugs, questions and feature requests about the central builds at []( and about the template at [](
*If your package vignettes need credentials (API keys, tokens, etc.) to knit, you might want to [precompute them]( since credentials cannot be used on the docs server.*
Before submission and before transfer, you could use the [approach documented by `pkgdown`]( or the [`tic` package]( for automatic deployment of the package's website. This would save you the hassle of running (and remembering to run) `pkgdown::build_site()` yourself every time the site needs to be updated. First refer to our [chapter on continuous integration](#ci) if you're not familiar with continuous integration. In any case, do not forget to update all occurrences of the website URL after transfer to the ropensci organization.
### Grouping functions in the reference {#function-grouping}
When your package has many functions, use grouping in the reference, which you can do more or less automatically.
If you use `roxygen2` above version 6.1.1, you should use the `@family` tag in your functions documentation to indicate grouping. This will give you links between functions in the local documentation of the installed package ("See also" section) *and* allow you to use the `pkgdown` `has_concept` function in the config file of your website. Non-rOpenSci example courtesy of [`optiRum`]( [family tag](, [`pkgdown` config file]( and [resulting reference section](
To customize the text of the cross-reference title created by roxygen2 (`Other {family}:`), refer to [roxygen2 docs regarding how to provide a `rd_family_title` list in `man/roxygen/meta.R`](
Less automatically, see the example of [`drake` website]( and [associated config file
### Branding of authors {#branding-of-authors}
You can make the names of (some) authors clickable by adding their URL, and you can even replace their names with a logo (think rOpenSci... or your organisation/company!). See [`pkgdown` documentation](
### Tweaking the navbar {#tweaking-the-navbar}
You can make your website content easier to browse by tweaking the navbar, refer to [`pkgdown` documentation]( In particular, note that if you name the main vignette of your package "pkg-name.Rmd", it'll be accessible from the navbar as a `Get started` link instead of via `Articles > Vignette Title`.
### Mathjax {#mathjax}
Once your package is transferred and it gets a website using our `pkgdown` template, if you want to use Mathjax you'll need to specify it in the `pkgdown` config file like so:
mathjax: true
### Package logo {#package-logo}
To use your package logo in the pkgdown homepage, refer to [`usethis::use_logo()`](
If your package doesn't have any logo, the [rOpenSci docs builder](#docsropensci) will use rOpenSci logo instead.
## Authorship {#authorship}
The `DESCRIPTION` file of a package should list package authors and contributors to a package, using the `Authors@R` syntax to indicate their roles (author/creator/contributor etc.) if there is more than one author, and using the comment field to indicate the ORCID ID of each author, if they have one (cf [this post]( See [this section of "Writing R Extensions"]( for details. If you feel that your reviewers have made a substantial contribution to the development of your package, you may list them in the `Authors@R` field with a Reviewer contributor type (`"rev"`), like so:
person("Bea", "Hernández", role = "rev",
comment = "Bea reviewed the package (v. X.X.XX) for rOpenSci, see <>"),
Only include reviewers after asking for their consent. Read more in [this blog post "Thanking Your Reviewers: Gratitude through Semantic Metadata"]( Please do not list editors as contributors. Your participation in and contribution to rOpenSci is thanks enough!
### Authorship of included code {#authorship-included-code}
Many packages include code from other software. Whether entire files or single functions are included from other packages, rOpenSci packages should follow [the CRAN *Repository Policy*](
> The ownership of copyright and intellectual property rights of all components of the package must be clear and unambiguous (including from the authors specification in the DESCRIPTION file). Where code is copied (or derived) from the work of others (including from R itself), care must be taken that any copyright/license statements are preserved and authorship is not misrepresented.
> Preferably, an ‘Authors@R' field would be used with ‘ctb' roles for the authors of such code. Alternatively, the ‘Author' field should list these authors as contributors.
> Where copyrights are held by an entity other than the package authors, this should preferably be indicated via ‘cph' roles in the ‘Authors@R' field, or using a ‘Copyright' field (if necessary referring to an inst/COPYRIGHTS file).
> Trademarks must be respected.
## Licence {#licence}
The package needs to have a [CRAN]( or [OSI]( accepted license.
For more explanations around licensing, refer to the [R packages book](
## Testing {#testing}
- All packages should pass `R CMD check`/`devtools::check()` on all major platforms.
- All packages should have a test suite that covers major functionality of the package. The tests should also cover the behavior of the package in case of errors.
- It is good practice to write unit tests for all functions, and all package code in general, ensuring key functionality is covered. Test coverage below 75% will likely require additional tests or explanation before being sent for review.
- We recommend using [testthat]( for writing tests. Strive to write tests as you write each new function. This serves the obvious need to have proper testing for the package, but allows you to think about various ways in which a function can fail, and to *defensively* code against those. [More information](
- Tests should be easy to understand. We suggest reading the blog post [*"Why Good Developers Write Bad Unit Tests"*]( by Michael Lynch.
- Packages with Shiny apps should use a unit-testing framework such as [`shinytest2`]( or [`shinytest`]( to test that interactive interfaces behave as expected.
- For testing your functions creating plots, we suggest using [vdiffr](, an extension of the testthat package; or [testthat snapshot tests](
- If your package interacts with web resources (web APIs and other sources of data on the web) you might find the [HTTP testing in R book by Scott Chamberlain and Maëlle Salmon]( relevant. Packages helping with HTTP testing (corresponding HTTP clients):
- [httptest2]( ([httr2](;
- [httptest]( ([httr](;
- [vcr]( ([httr](, [crul](;
- [webfakes]( ([httr](, [httr2](, [crul](, [curl](
- testthat has a function `skip_on_cran()` that you can use to not run tests on CRAN. We recommend using this on all functions that are API calls since they are quite likely to fail on CRAN. These tests should still run on continuous integration. Note that from testthat 3.1.2 `skip_if_offline()` automatically calls `skip_on_cran()`. More info on [CRAN preparedness for API wrappers](
- If your package interacts with a database you might find [dittodb]( useful.
- Once you've set up [continuous integration (CI)](#ci), use your package's code coverage report (cf [this section of our book](#coverage)) to identify untested lines, and to add further tests.
- Even if you use [continuous integration](#ci), we recommend that you run tests locally prior to submitting your package, as some tests are often skipped (you may need to set `Sys.setenv(NOT_CRAN="true")` in order to ensure all tests are run). In addition, we recommend that prior to submitting your package, you use MangoTheCat's [**goodpractice**]( package to check your package for likely sources of errors, and run `spelling::spell_check_package()` to find spelling errors in documentation.
## Examples {#examples}
- Include extensive examples in the documentation. In addition to demonstrating how to use the package, these can act as an easy way to test package functionality before there are proper tests. However, keep in mind we require tests in contributed packages.
- You can run examples with `devtools::run_examples()`. Note that when you run R CMD CHECK or equivalent (e.g., `devtools::check()`) your examples that are not wrapped in `\dontrun{}` or `\donttest{}` are run. Refer to the [summary table]( in roxygen2 docs.
- To safe-guard examples (e.g. requiring authentication) to be run on CRAN you need to use `\dontrun{}`. However, for a first submission CRAN won't let you have all examples escaped so. In this case you might add some small toy examples, or wrap example code in `try()`. Also refer to the `@exampleIf` tag present, at the time of writing, in roxygen2 development version.
- In addition to running examples locally on your own computer, we strongly advise that you run examples on one of the [continuous integration systems](#ci). Again, examples that are not wrapped in `\dontrun{}` or `\donttest{}` will be run, but for those that are you can configure your continuous integration builds to run them via R CMD check arguments `--run-dontrun` and/or `--run-donttest`.
## Package dependencies {#pkgdependencies}
- Use `Imports` instead of `Depends` for packages providing functions from other packages. Make sure to list packages used for testing (`testthat`), and documentation (`knitr`, `roxygen2`) in your `Suggests` section of package dependencies (if you use `usethis` for adding testing infrastructure via [`usethis::use_testthat()`]( or a vignette via [usethis::use\_vignette()](, the necessary packages will be added to `DESCRIPTION`). If you use any package in the examples or tests of your package, make sure to list it in `Suggests`, if not already listed in `Imports`.
- If your (not Bioconductor) package depends on Bioconductor packages, make sure the installation instructions in the README and vignette are clear enough even for an user who is not familiar with the Bioconductor release cycle.
- Should the user use [`BiocManager`]( (recommended)? Document this.
- Is the automatic installation of Bioconductor packages by `install.packages()` enough? In that case, mention that the user needs to run `setRepositories()` if they haven't set the necessary Bioconductor repositories yet.
- If your package depends on Bioconductor after a certain version, mention it in DESCRIPTION and in the installation instructions.
- Specifying minimum dependencies (e.g. `glue (>= 1.3.0)` instead of just `glue`) should be a conscious choice. If you know for a fact that your package will break below a certain dependency version, specify it explicitly.
But if you don't, then no need to specify a minimum dependency. In that case when a user reports a bug which is explicitly related to an older version of a dependency then address it then.
An example of bad practice would be for a developer to consider the versions of their current state of dependencies to be the minimal version. That would needlessly force everyone to upgrade (causing issues with other packages) when there is no good reason behind that version choice.
- For most cases where you must expose functions from dependencies to the user, you should import and re-export those individual functions rather than listing them in the `Depends` fields. For instance, if functions in your package produce `raster` objects, you might re-export only printing and plotting functions from the **raster** package.
- If your package uses a *system* dependency, you should
- Indicate it in DESCRIPTION;
- Check that it is listed by [`sysreqsdb`]( to allow automatic tools to install it, and [submit a contribution]( if not;
- Check for it in a `configure` script ([example]( and give a helpful error message if it cannot be found ([example](
`configure` scripts can be challenging as they often require hacky solutions
to make diverse system dependencies work across systems. Use examples ([more here]( as a starting point but note that it is common to encounter bugs and edge cases and often violate CRAN policies. Do not hesitate to [ask for help on our forum](
- Consider the trade-offs involved in relying on a package as a dependency. On one hand,
using dependencies reduces coding effort, and can build on useful functionality developed by
others, especially if the dependency performs complex tasks, is high-performance,
and/or is well vetted and tested. On the other hand, having many dependencies
places a burden on the maintainer to keep up with changes in those packages, at risk
to your package's long-term sustainability. It also
increases installation time and size, primarily a consideration on your and others' development cycle, and in automated build systems. "Heavy" packages - those with many dependencies themselves, and those with large amounts of compiled code - increase this cost. Here are some approaches to reducing
- Small, simple functions from a dependency package may be better copied into
your own package if the dependency if you are using only a few functions
in an otherwise large or heavy dependency. (See [*Authorship* section
above](#authorship-included-code) for how to acknowledge original authors
of copied code.) On the other hand, complex functions with many edge
cases (e.g. parsers) require considerable testing and vetting.
- An common example of this is in returning tidyverse-style "tibbles" from package
functions that provide data.
One can avoid the modestly heavy **tibble** package dependency by returning
a tibble created by modifying a data frame like so:
class(df) <- c("tbl_df", "tbl", "data.frame")
(Note that this approach is [not universally endorsed](
- Ensure that you are using the package where the function is defined,
rather than one where it is re-exported. For instance many functions in **devtools** can be found in smaller specialty packages such as **sessioninfo**. The `%>%` function
should be imported from **magrittr**, where it is defined, rather than the heavier
**dplyr**, which re-exports it.
- Some dependencies are preferred because they provide easier to interpret
function names and syntax than base R solutions. If this is the primary
reason for using a function in a heavy dependency, consider wrapping
the base R approach in a nicely-named internal function in your package. See e.g. the [rlang R script providing functions with a syntax similar to purrr functions](
- If dependencies have overlapping functionality, see if you can rely on only one.
- More dependency-management tips can be found [in this post by
Scott Chamberlain](
## Recommended scaffolding {#recommended-scaffolding}
- For HTTP requests we recommend using [curl], [crul], [httr] or [httr2] over [RCurl]. If you like low level clients for HTTP, [curl] is best, whereas [crul] or [httr] are better for higher level access. [crul] is maintained by rOpenSci. We recommend the rOpenSci maintained packages [webmockr] for mocking HTTP requests, and [vcr] for caching HTTP requests in package tests.
- For parsing JSON, use [jsonlite] instead of [rjson] or [RJSONIO].
- For parsing, creating, and manipulating XML, we strongly recommend [xml2] for most cases. [You can refer to Daniel Nüst's notes about migration from XML to xml2](
- For spatial data, the [sp] package should be considered deprecated in favor of [sf], and the packages [rgdal], [maptools], and [rgeos] will be retired by the end of 2023. We recommend use of the spatial suites developed by the [r-spatial]( and [rspatial]( communities. See [this GitHub issue]( for relevant discussions.
## Version Control {#version-control}
- Your package source files have to be under version control, more specifically tracked with [Git]( You might find the [gert package]( relevant, as well as some of [usethis Git/GitHub related functionality](; you can however use git as you want.
- Make sure to list "scrap" such as `.DS_Store` files in .gitignore. You might find the [gitignore package]( relevant.
- A later section of this book contains some [git workflow tips](#gitflow).
## Miscellaneous CRAN gotchas {#crangotchas}
This is a collection of CRAN gotchas that are worth avoiding at the outset.
- Make sure your package title is in Title Case.
- Do not put a period on the end of your title.
- Do not put 'in R' or 'with R' in your title as this is obvious from packages hosted on CRAN. If you would like this information to be displayed on your website nonetheless, check the [`pkgdown` documentation]( to learn how to override this.
- Avoid starting the description with the package name or "This package ...".
- Make sure you include links to websites if you wrap a web API, scrape data from a site, etc. in the `Description` field of your `DESCRIPTION` file. URLs should be enclosed in angle brackets, e.g. `<>`.
- In both the `Title` and `Description` fields, the names of packages or other external software must be quoted using single quotes (e.g., *'Rcpp' Integration for the 'Armadillo' Templated Linear Algebra Library*).
- Avoid long running tests and examples. Consider `testthat::skip_on_cran` in tests to skip things that take a long time but still test them locally and on [continuous integration](#ci).
- Include top-level files such as ``, continuous integration configuration files, in your `.Rbuildignore` file.
### CRAN checks {#cranchecks}
Once your package is on CRAN, it will be [regularly checked on different platforms]( Failures of such checks, when not false positives, can lead to the CRAN team's reaching out. You can monitor the state of the CRAN checks via
- the [`foghorn` package](
- the [CRAN checks API]( maintained by rOpenSci, that provides [badges](
## Bioconductor gotchas {#bioconductor-gotchas}
If you intend your package to be submitted to, or if your package is on, Bioconductor, refer to [Bioconductor packaging guidelines]( and the [updated developer book](
## Further guidance {#further-guidance}
- If you are submitting a package to rOpenSci via the [software-review repo](, you can direct further questions to the rOpenSci team in the issue tracker, or in our [discussion forum](
- Before submitting a package use the [**goodpractice**]( package (`goodpractice::gp()`) as a guide to improve your package, since most exceptions to it will need to be justified. E.g. the use of `foo` might be generally bad and therefore flagged by `goodpractice` but you had a good reason to use it in your package.
- Read, incorporate, and act on advice from the [*Collaboration Guide* chapter](#collaboration).
### Learning about package development {#learning-about-package-development}
#### Books {#books}
- [Hadley Wickham and Jenny Bryan's *R packages* book]( is an excellent, readable resource on package development which is available for [free online]( (and [print -- link to former version by Hadley Wickham as the new version is not published yet as of June 2022](
- [Writing R Extensions]( is the canonical, usually most up-to-date, reference for creating R packages.
- [*Mastering Software Development in R* by Roger D. Peng, Sean Kross, and Brooke Anderson](
- [*Advanced R* by Hadley Wickham](
#### Tutorials {#tutorials}
- [Hilary Parker's famous blog post *Writing an R package from scratch*]( or [its updated version by Tomas Westlake]( that shows how to do the same more efficiently using `usethis`.
- [this workflow description by Emil Hvitfeldt](
- [This pictorial by Matthew J Denny](
#### Blogs {#blogs}
- [R-hub blog](
- Some posts of the [rOpenSci blog]( e.g. ["How to precompute package vignettes or pkgdown articles"](
- Package Development Corner section of [rOpenSci newsletter](
- Some posts of the [tidyverse blog]( e.g. ["Upgrading to testthat edition 3"](
#### MOOCs {#moo-cs}
There is a [Coursera specialization corresponding to the book by Roger Peng, Sean Kross and Brooke Anderson](, with a course specifically about R packages.