Motivation and background

The Comprehensive R Archive Network (CRAN, https://CRAN.R-project.org/), comprised of approximately one hundred mirror pages around the world along with a content-delivery network (CDN), is the canonical site for downloading not only the base R system (R Core Team 2025) but also more than twenty thousand extension packages (actually, 23088 at the time of writing) contributed by users from the R community. CRAN is a very useful resource within the R ecosystem, but its content can be hard to grasp and navigate. Especially users new to R can struggle with getting started and finding the relevant R packages for the tasks they want to accomplish.

To mitigate this problem, Zeileis (2005), in cooperation with the CRAN team, introduced “CRAN Task Views” that provide guidance about which CRAN packages are relevant for tasks related to a given topic. Task views offer a brief overview of the included packages on a dedicated CRAN page (see https://CRAN.R-project.org/web/views/ for an overview) and also enable the automatic installation of all packages from a task view using the package (Zeileis and Hornik 2024). The views are intended to have a sharp focus so that it is sufficiently clear which packages should be included (or excluded). They are not meant to endorse the “best” packages for a given task but they can distinguish a shorter list of most relevant/important core packages from the remaining regular packages.

While CRAN Task Views alone were certainly not able to overcome all the challenges of navigating CRAN, they proved to be useful enough to be continued over the subsequent years. However, due to the growth of CRAN (see, e.g., Hornik, Ligges, and Zeileis 2024) and of the R community as a whole since the introduction of task views in 2005, the thriving of the task views was limited by several design decisions regarding their format and the corresponding workflows:

This setup worked sufficiently well in 2005 when there were about 500 packages on CRAN and initially 4 task views, listing on average 20 packages each. (Within a year, the number of task views increased to 12.) But by now there are 49 task views, with median and mean numbers of CRAN packages covered 109 and 122, respectively. Overall, these task views cover 4992 CRAN packages, which is about 22% of all CRAN packages. This change in scope and scale necessitated a change in infrastructure and workflows that the new CRAN Task View Initiative, described in detail in the next section, aims to provide.

New design

Motivated by the challenges from the growth of CRAN and the R community as a whole, almost all aspects of the CRAN Task Views were rethought and relaunched in 2021/22 in order to facilitate maintenance and foster more interactions with the R community. The important changes are:

More details on the CRAN Task View Initiative are available in the GitHub repository https://github.com/cran-task-views/ctv. This provides an overview of the activities, detailed documentation, and the possibility to raise issues that concern the initiative as a whole (rather than individual task views).

The current CRAN Task View Editors are Roger Bivand, Dirk Eddelbuettel, Julia Piaskowski, Nathalie Vialaneix, and Achim Zeileis. Former contributors include: Henrik Bengtsson, Rocío Joo, David Meyer, and Heather Turner. The primary contributor from the CRAN team is Kurt Hornik.

Using task views

First and foremost, the web page of each task view can be read by interested users (see Figure 1 for an example). The clear structure and focus of the task views should help the readers to quickly gain a first overview of a topic and to search for specific relevant packages more efficiently.

Screenshot of the header and introduction of the Econometrics task view, captured on 2025-04-01 at https://CRAN.R-project.org/view=Econometrics. The header displays the title (Econometrics), maintainers (Achim Zeileis, Grant McDermott, Kevin Tappe), contact e-mail address, version/date, URL, GitHub link, information for potential contributors, the recommended citation, and installation instructions. The introduction starts by outlining the scope and links to other related task views (Finance, TimeSeries, CausalInference).

Screenshot of the header and introduction of the Econometrics task view.

Another benefit of task views that has probably been underappreciated for a long time is that they allow the easy installation of the associated packages (either all of them or just the core packages). The headers of all task view web pages now promote this possibility explicitly. To make use of this, the ctv package needs to be installed, e.g., via

install.packages("ctv")

The package provides the two functions install.views() and update.views(), where the latter only installs those packages which are not installed and up-to-date. For example, in order to install the full “Econometrics” task view either one of the following two calls can be used:

ctv::install.views("Econometrics")
ctv::update.views("Econometrics")

Moreover, two functions are provided for querying the information from task views from within R. First, information on a single task view can be obtained with the ctv() function.

ctv::ctv("Econometrics")
## CRAN Task View
## --------------
## Name:       Econometrics
## Topic:      Econometrics
## Maintainer: Achim Zeileis, Grant McDermott, Kevin Tappe
## Contact:    Achim.Zeileis@R-project.org
## Version:    2025-10-28
## Repository: https://CRAN.R-project.org
## Source:     https://github.com/cran-task-views/Econometrics/
## Packages:   AER*, alpaca, aod, apollo, apt, bacondecomp, bayesm, betareg, bife,
##             bimets, BMA, BMS, boot, bootstrap, brglm, CADFtest, car*, censReg,
...

To list all task views available from CRAN, the function available.views() can be used:

ctv::available.views()
## CRAN Task Views
## ---------------
## Name: ActuarialScience
## Topic: Actuarial Science
## Maintainer: Christophe Dutang, Vincent Goulet
## Repository: https://CRAN.R-project.org
## ---------------
## Name: Agriculture
## Topic: Agricultural Science
## Maintainer: Julia Piaskowski, Adam Sparks, Adrian Correndo
## Repository: https://CRAN.R-project.org
## ---------------
...

The objects returned by ctv() and available.views() include additional information which is not shown by the print() method. This may be useful for more specific computations based on the task views. For example, a citation object (Hornik, Murdoch, and Zeileis 2012) can be obtained from the list returned by ctv().

ctv::ctv("Econometrics")$citation
## 
##   Zeileis A, McDermott G, Tappe K (2025). _CRAN Task View:
##   Econometrics_. Version 2025-10-28,
##   <https://CRAN.R-project.org/view=Econometrics>.
## 
## A BibTeX entry for LaTeX users is
## 
##   @Manual{,
##     author = {Achim Zeileis and Grant McDermott and Kevin Tappe},
##     title = {CRAN Task View: Econometrics},
##     year = {2025},
##     note = {Version 2025-10-28},
##     url = {https://CRAN.R-project.org/view=Econometrics},
##   }

Contributing

Users from the R community can contribute in two ways to the CRAN Task View Initiative: They can either provide suggestions for an existing task view, or they can propose a new one on a topic that is not yet covered. In either case, all contributions must be made under the code of conduct.

Contributions to existing task views are welcome, encouraged, and in fact crucial for keeping the task views up to date. Typical contributions would be improvements in existing content (e.g., adding details, clarifications, or corrections) or suggestions of additional content (e.g., packages or links). To facilitate such contributions, each task view includes the e-mail address of the principal maintainer as well as a link to the associated GitHub repository. Thus, contributors can choose the most convenient alternative among the following ones:

To avoid having a pull request become more involved or disruptive, it is frequently suggested to first discuss proposed changes by raising an issue, and to make sure that the modified task view file still works correctly (see Section 6).

For proposing new task views, the CRAN Task View Initiative provides a standardized workflow including a review and onboarding process. All steps are detailed at https://github.com/cran-task-views/ctv/blob/main/Proposal.md. In the following, we just outline the essential aspects.

First, it is important that the prospective maintainers consider the time and work that is required to put together a proposal, to refine it during the review and onboarding process, and most importantly to actively maintain the task view in the future.

Second, a fundamental and very crucial step is to formulate the topic of the new task view so that it has a clear scope that is neither too narrow nor too wide. The goal is not to cover “every package” remotely related to the topic but rather the set of packages that clearly fall within the scope. The coverage should be similar to what an introductory text book on the topic would cover. Non-CRAN packages may also be included but the focus of CRAN task views should be packages on CRAN (as the name conveys). Finally, task views should not rate the packages or endorse certain “best” packages but rather give an overview of what is available. A bit of emphasis to the more important packages can be given in two ways: (a) The most important packages can be flagged as core packages. (b) In the information text the more important packages can be listed first in the respective sections.

Third, based on the information formulated as outlined above, the proposal can be made in the GitHub issues of the ctv repository. This initiates a first review that is carried out in the comments of the issue tracker which are open to all members of the community. In all cases, the CRAN Task View Editors are explicitly invited to comment, as may be maintainers of related task views or of relevant core packages etc. Provided that there is sufficient endorsement from the CRAN Task View Editors, typically after revisions and refinements from the prospective maintainers, a proposal is accepted, initiating an onboarding process that leads to the publication of the task view on CRAN.

Finally, the maintainers of the task view are responsible for keeping it up to date by checking CRAN regularly. Contributions from the community, as described at the beginning of this section, are eminently useful for this and hence explicitly encouraged. Moreover, some R packages like (Dijk 2023) can support the maintainers in discovering new relevant packages on CRAN.

Handling package archivals

The CRAN packages listed in task views should ideally be maintained actively, so that improved versions are released by the corresponding maintainers in case the daily CRAN checks discover any issues. However, it is not straightforward to test for active maintenance fully automatically and even actively maintained packages may be temporarily archived on CRAN. Hence, the following strategy is adopted within the CRAN Task View Initiative: When a CRAN package from a task view is archived, it is still listed in the task view like before. It is only flagged as archived in the text and is not installed automatically anymore by install.views() and update.views().

This strategy gives both the package maintainers and the task view maintainers some time to resolve the situation. Specifically, the task view maintainers can decide whether to

To help discovering archived packages and initiating one of the actions above, the CRAN team regularly checks whether any task view contains packages that have been archived on CRAN for 60 days or more. If so, they create an issue in the corresponding task view repository.

After the period of grace (100 days) ends, the situation should be resolved by the task view maintainers, typically by excluding packages that are still archived from the task view. For sufficiently relevant packages, it may be sensible to replace the package listing by a link, e.g., to a GitHub repository for the package.

R/Markdown format

The file format for CRAN task views leverages the R/Markdown format (Xie, Allaire, and Grolemund 2018) so that standard Markdown can be used for formatting and structuring the text and a handful of special R functions are provided to link to CRAN packages, other task views, GitHub projects, etc. The format is mostly self-explanatory and is illustrated below using an excerpt from the Econometrics task view:

---
name: Econometrics
topic: Econometrics
maintainer: Achim Zeileis, Grant McDermott, Kevin Tappe
email: Achim.Zeileis@R-project.org
version: 2025-04-01
source: https://github.com/cran-task-views/Econometrics/
---

Base R ships with a lot of functionality useful for (computational) econometrics,
in particular in the stats package. This functionality is complemented by many
packages on CRAN, a brief overview is given below. There is also a certain
overlap between the tools for econometrics in this view and those in the task
views on `r view("Finance")`, `r view("TimeSeries")`, and
`r view("CausalInference")`.

Further information can be formatted with standard Markdown syntax, e.g., for
_emphasizing text_ or showing something really important in **bold face**.
R/Markdown syntax with special functions can be used to link to a standard
package like `r pkg("mlogit")` or an important "core" package like
`r pkg("AER", priority = "core")`.

### Links
- [The Title of a Relevant Homepage](http://path/to/homepage/)

The document structure consists of three main blocks: (a) Some metainformation is given in the YAML header at the beginning (separated by lines with ---), followed by (b) the information in the main text, and (c) a concluding special section called ### Links. Details are explained in the official documentation: https://github.com/cran-task-views/ctv/blob/main/Documentation.md.

The information in the main text should be a short description of the packages, explaining which packages are useful for which tasks. Additionally, short R code chunks with special functions are used for linking to CRAN resources: pkg() for regular packages, pkg(..., priority = "core") for important core packages, and view() for related task views. Moreover, code projects in other repositories can be linked by dedicated functions, e.g., bioc() or github() for packages on Bioconductor or GitHub, respectively.

In order to check whether a task view file has been formatted properly it can be read into R and rendered to HTML (see also Figure 1) which can be opened and inspected in a browser. Additionally, the function check_ctv_packages() can be used to check whether some of the listed packages are actually not available on CRAN or not currently maintained (archived). The functions are illustrated below, assuming that the Econometrics.md file is in the local working directory:

ctv::ctv2html("Econometrics.md", cran = TRUE)
browseURL("Econometrics.html")
ctv::check_ctv_packages("Econometrics.md")

Note that the extension .md (rather than .Rmd) has been adopted for the files so that GitHub renders a Markdown preview on the fly. Finally, in case the maintainers of a task view want to leverage GitHub Actions, a validate-ctv workflow is provided at https://github.com/cran-task-views/ctv/tree/main/validate-ctv which runs the functions above and processes the results.

Available task views

Currently, there are 49 task views on CRAN with the following names and maintainers:

Outlook

The new CRAN Task View Initiative has redesigned and relaunched the infrastructure and workflows for CRAN Task Views so that they can thrive in the years to come. In particular, many tools are used that are well-established in the R community such as / or collaborations through GitHub projects. Moreover, various steps have been taken in order to assure that all task views are actively maintained and foster contributions from the community, either in terms of additions/improvements for existing task views, or in the form of new proposals.

Since announcing the new initiative in Spring 2022, many task views were already improved, e.g., by adding new content, extending the maintainer teams, or incorporating feedback from the community. Additionally, there were already twelve successful new task view proposals (ActuarialScience, Agriculture, CausalInference, CompositionalData, DynamicVisualizations, Epidemiology, MixedModels, NetworkAnalysis, Omics, Paleontology, Phylogenetics, SportsAnalytics). This shows that the review and onboarding process for the new task views works successfully. While the review and revision times are sometimes somewhat long (as the work on the task views is typically not a top priority in the jobs of either the editors or the task view authors), we feel that the reviews are very constructive, often involve other community members, and yield task views of higher quality.

While these steps already accomplished important improvements in the initiative, further challenges remain for the future. Apart from improving the breadth and depth of the task views, the most important aim is probably to better connect with those R users who would profit from the information provided in the task views. We feel that this was easier in the mid-2000s for two reasons:

  1. CRAN (and hence its task views) were actively browsed/searched by many R users, whereas today many more users will expect that useful content is presented to them, e.g., via either search engines or large language models.

  2. Twenty years ago, the R community was smaller, and there was a common understanding of “free” software as a contract between developers and users to actively share in the progress of a given project (as in the spirit of the “Debian Social Contract”, see https://www.debian.org/social_contract, especially point 2). Since then the R community has grown in size and complexity, the typical career paths of new members have changed, and R is increasingly perceived as one among many free-of-charge software applications. But in contrast to R, most of the other free-of-charge software is actually paid for by surrendering data, not by sharing a responsibility for the progress of the project.

Both of these points have probably affected the expectations of users with regard to how much effort to apply to learning about the software they have chosen to use (but which they are not purchasing). This needs to be taken into account in further improvement of the effectiveness of task views. Therefore, one goal is to improve discoverability, including tags for search engine optimization, and prompts for chatbots based on large language models (LLMs). In terms of tags, DublinCore and Highwire Press metainformation tags have already been added to the HTML pages. In terms of LLM-based chatbots, it appears that prompts such as “Where can I find more information on R packages for X?”, where X is (closely related to) a task view topic, typically links to the corresponding CRAN Task Views.

Another goal is to better connect with those sub-communities for whom the task views are relevant. This could be accomplished by including more representatives from these sub-communities in broader teams of task view maintainers, in order to restore the open source social contract and sharing the responsibility for the task views. Moreover, listing the task views in more online overviews/tutorials geared towards these different sub-communities would help to spread the information.

We end with a call to the R community to support us in accomplishing these goals:

Any of the above are highly appreciated and would help us and the maintainers of CRAN Task Views to continue to aid R users and developers in making topical and informed choices about the R packages in their workflows.

Dijk, Dylan. 2023. CTVsuggest: CRAN Task View Package Recommendations. https://dylandijk.github.io/CTVsuggest/.
Hornik, Kurt, Uwe Ligges, and Achim Zeileis. 2024. “Changes on CRAN.” The R Journal 16 (4): 2073–4859. https://journal.R-project.org/news/RJ-2024-4-cran/.
Hornik, Kurt, Duncan Murdoch, and Achim Zeileis. 2012. “Who Did What? The Roles of R Package Authors and How to Refer to Them.” The R Journal 4 (1): 64–69. https://doi.org/10.32614/RJ-2012-009.
MacFarlane, John. 2025. Pandoc: A Universal Document Converter. https://pandoc.org/.
R Core Team. 2025. R: A Language and Environment for Statistical Computing. Vienna, Austria: R Foundation for Statistical Computing. https://www.R-project.org/.
Theußl, Stefan, and Achim Zeileis. 2009. “Collaborative Software Development Using R-Forge.” The R Journal 1 (1): 9–14. https://doi.org/10.32614/RJ-2009-007.
Xie, Yihui. 2015. Dynamic Documents with R and knitr. 2nd ed. Boca Raton: Chapman & Hall/CRC. https://doi.org/10.1201/9781315382487.
Xie, Yihui, J. J. Allaire, and Garrett Grolemund. 2018. R Markdown: The Definitive Guide. Boca Raton: Chapman & Hall/CRC. https://doi.org/10.1201/9781138359444.
Zeileis, Achim. 2005. “CRAN Task Views.” R News 5 (1): 39–40. https://CRAN.R-project.org/doc/Rnews/.
Zeileis, Achim, and Kurt Hornik. 2024. ctv: CRAN Task Views. https://doi.org/10.32614/CRAN.package.ctv.