Learn R Programming
⚠️There's a newer version (7.13.10) of this package.Take me there.

The drake R package

Data analysis can be slow. A round of scientific computation can take several minutes, hours, or even days to complete. After it finishes, if you update your code or data, your hard-earned results may no longer be valid. How much of that valuable output can you keep, and how much do you need to update? How much runtime must you endure all over again?

For projects in R, the drake package can help. It analyzes your workflow, skips steps with up-to-date results, and orchestrates the rest with optional distributed computing. At the end, drake provides evidence that your results match the underlying code and data, which increases your ability to trust your research.

6-minute video

Visit the first page of the manual to watch a short introduction.

What gets done stays done.

Too many data science projects follow a Sisyphean loop:

  1. Launch the code.
  2. Wait while it runs.
  3. Discover an issue.
  4. Rerun from scratch.

Ordinarily, it is hard to avoid rerunning the code from scratch.

But with drake, you can automatically

  1. Launch the parts that changed since last time.
  2. Skip the rest.

How it works

To set up a project, load your packages,

library(drake)
library(dplyr)
library(ggplot2)

load your custom functions,

create_plot <- function(data) {
  ggplot(data, aes(x = Petal.Width, fill = Species)) +
    geom_histogram()
}

check any supporting files (optional),

# Get the files with drake_example("main").
file.exists("raw_data.xlsx")
#> [1] TRUE
file.exists("report.Rmd")
#> [1] TRUE

and plan what you are going to do.

plan <- drake_plan(
  raw_data = readxl::read_excel(file_in("raw_data.xlsx")),
  data = raw_data %>%
    mutate(Species = forcats::fct_inorder(Species)),
  hist = create_plot(data),
  fit = lm(Sepal.Width ~ Petal.Width + Species, data),
  report = rmarkdown::render(
    knitr_in("report.Rmd"),
    output_file = file_out("report.html"),
    quiet = TRUE
  )
)
plan
#> # A tibble: 5 x 2
#>   target   command                                                         
#>   <chr>    <expr>                                                          
#> 1 raw_data readxl::read_excel(file_in("raw_data.xlsx"))                   …
#> 2 data     raw_data %>% mutate(Species = forcats::fct_inorder(Species))   …
#> 3 hist     create_plot(data)                                              …
#> 4 fit      lm(Sepal.Width ~ Petal.Width + Species, data)                  …
#> 5 report   rmarkdown::render(knitr_in("report.Rmd"), output_file = file_ou…

So far, we have just been setting the stage. Use make() to do the real work. Targets are built in the correct order regardless of the row order of plan.

make(plan)
#> target raw_data
#> target data
#> target fit
#> target hist
#> target report

Except for files like report.html, your output is stored in a hidden .drake/ folder. Reading it back is easy.

readd(data) # See also loadd().
#> # A tibble: 150 x 5
#>    Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#>           <dbl>       <dbl>        <dbl>       <dbl> <fct>  
#>  1          5.1         3.5          1.4         0.2 setosa 
#>  2          4.9         3            1.4         0.2 setosa 
#>  3          4.7         3.2          1.3         0.2 setosa 
#>  4          4.6         3.1          1.5         0.2 setosa 
#>  5          5           3.6          1.4         0.2 setosa 
#>  6          5.4         3.9          1.7         0.4 setosa 
#>  7          4.6         3.4          1.4         0.3 setosa 
#>  8          5           3.4          1.5         0.2 setosa 
#>  9          4.4         2.9          1.4         0.2 setosa 
#> 10          4.9         3.1          1.5         0.1 setosa 
#> # … with 140 more rows

You may look back on your work and see room for improvement, but it’s all good! The whole point of drake is to help you go back and change things quickly and painlessly. For example, we forgot to give our histogram a bin width.

readd(hist)
#> `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

So let’s fix the plotting function.

create_plot <- function(data) {
  ggplot(data, aes(x = Petal.Width, fill = Species)) +
    geom_histogram(binwidth = 0.25) +
    theme_gray(20)
}

drake knows which results are affected.

config <- drake_config(plan)
vis_drake_graph(config) # Interactive graph: zoom, drag, etc.

The next make() just builds hist and report.html. No point in wasting time on the data or model.

make(plan)
#> target hist
#> target report
loadd(hist)
hist

Reproducibility with confidence

The R community emphasizes reproducibility. Traditional themes include scientific replicability, literate programming with knitr, and version control with git. But internal consistency is important too. Reproducibility carries the promise that your output matches the code and data you say you used. With the exception of non-default triggers and hasty mode, drake strives to keep this promise.

Evidence

Suppose you are reviewing someone else’s data analysis project for reproducibility. You scrutinize it carefully, checking that the datasets are available and the documentation is thorough. But could you re-create the results without the help of the original author? With drake, it is quick and easy to find out.

make(plan)
#> All targets are already up to date.

config <- drake_config(plan)
outdated(config)
#> character(0)

With everything already up to date, you have tangible evidence of reproducibility. Even though you did not re-create the results, you know the results are re-creatable. They faithfully show what the code is producing. Given the right package environment and system configuration, you have everything you need to reproduce all the output by yourself.

Ease

When it comes time to actually rerun the entire project, you have much more confidence. Starting over from scratch is trivially easy.

clean()    # Remove the original author's results.
make(plan) # Independently re-create the results from the code and input data.
#> target raw_data
#> target data
#> target fit
#> target hist
#> target report

History and provenance

As of version 7.5.0, drake tracks the history and provenance of your targets: what you built, when you built it, how you built it, the arguments you used in your function calls, and how to get the data back. (Disable with make(history = FALSE))

history <- drake_history(analyze = TRUE)
history
#> # A tibble: 12 x 10
#>    target time  hash  exists command  runtime   seed latest quiet
#>    <chr>  <chr> <chr> <lgl>  <chr>      <dbl>  <int> <lgl>  <lgl>
#>  1 data   2019… e580… TRUE   raw_da… 0.001    1.29e9 FALSE  NA   
#>  2 data   2019… e580… TRUE   raw_da… 0        1.29e9 TRUE   NA   
#>  3 fit    2019… 62a1… TRUE   lm(Sep… 0.002    1.11e9 FALSE  NA   
#>  4 fit    2019… 62a1… TRUE   lm(Sep… 0.001000 1.11e9 TRUE   NA   
#>  5 hist   2019… 10bc… TRUE   create… 0.006    2.10e8 FALSE  NA   
#>  6 hist   2019… 5252… TRUE   create… 0.004    2.10e8 FALSE  NA   
#>  7 hist   2019… 00fa… TRUE   create… 0.007    2.10e8 TRUE   NA   
#>  8 raw_d… 2019… 6317… TRUE   "readx… 0.009    1.20e9 FALSE  NA   
#>  9 raw_d… 2019… 6317… TRUE   "readx… 0.00600  1.20e9 TRUE   NA   
#> 10 report 2019… 3e2b… TRUE   "rmark… 0.481    1.30e9 FALSE  TRUE 
#> 11 report 2019… 3e2b… TRUE   "rmark… 0.358    1.30e9 FALSE  TRUE 
#> 12 report 2019… 3e2b… TRUE   "rmark… 0.356    1.30e9 TRUE   TRUE 
#> # … with 1 more variable: output_file <chr>

Remarks:

  • The quiet column appears above because one of the drake_plan() commands has knit(quiet = TRUE).
  • The hash column identifies all the previous the versions of your targets. As long as exists is TRUE, you can recover old data.
  • Advanced: if you use make(cache_log_file = TRUE) and put the cache log file under version control, you can match the hashes from drake_history() with the git commit history of your code.

Let’s use the history to recover the oldest histogram.

hash <- history %>%
  filter(target == "hist") %>%
  pull(hash) %>%
  head(n = 1)
cache <- drake_cache()
cache$get_value(hash)
#> `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

Automated recovery and renaming

Note: this feature is still experimental.

In drake version 7.5.0 and above, make(recover = TRUE) can salvage old targets from the distant past. This may not be a good idea if your external dependencies have changed a lot over time (R version, package environment, etc) but it can be useful under the right circumstances.

# Is the data really gone?
clean() # garbage_collection = FALSE

# Nope!
make(plan, recover = TRUE) # The report still builds since report.md is gone.
#> recover raw_data
#> recover data
#> recover fit
#> recover hist
#> target report

# When was the raw data *really* first built?
diagnose(raw_data)$date
#> [1] "2019-07-18 20:19:48.110163 -0400 GMT"

You can even rename your targets! All you have to do is use the same target seed as last time. Just be aware that this invalidates downstream targets.

# Get the old seed.
old_seed <- diagnose(data)$seed

# Now rename the data and supply the old seed.
plan <- drake_plan(
  raw_data = readxl::read_excel(file_in("raw_data.xlsx")),
  
  # Previously just named "data".
  iris_data = target(
    raw_data %>%
      mutate(Species = forcats::fct_inorder(Species)),
    seed = !!old_seed
  ),

  # `iris_data` will be recovered from `data`,
  # but `hist` and `fit` have changed commands,
  # so they will build from scratch.
  hist = create_plot(iris_data),
  fit = lm(Sepal.Width ~ Petal.Width + Species, iris_data),
  report = rmarkdown::render(
    knitr_in("report.Rmd"),
    output_file = file_out("report.html"),
    quiet = TRUE
  )
)

make(plan, recover = TRUE)
#> recover iris_data
#> target fit
#> target hist
#> target report

Independent replication

With even more evidence and confidence, you can invest the time to independently replicate the original code base if necessary. Up until this point, you relied on basic drake functions such as make(), so you may not have needed to peek at any substantive author-defined code in advance. In that case, you can stay usefully ignorant as you reimplement the original author’s methodology. In other words, drake could potentially improve the integrity of independent replication.

Readability and transparency

Ideally, independent observers should be able to read your code and understand it. drake helps in several ways.

  • The workflow plan data frame explicitly outlines the steps of the analysis, and vis_drake_graph() visualizes how those steps depend on each other.
  • drake takes care of the parallel scheduling and high-performance computing (HPC) for you. That means the HPC code is no longer tangled up with the code that actually expresses your ideas.
  • You can generate large collections of targets without necessarily changing your code base of imported functions, another nice separation between the concepts and the execution of your workflow

Scale up and out.

Not every project can complete in a single R session on your laptop. Some projects need more speed or computing power. Some require a few local processor cores, and some need large high-performance computing systems. But parallel computing is hard. Your tables and figures depend on your analysis results, and your analyses depend on your datasets, so some tasks must finish before others even begin. drake knows what to do. Parallelism is implicit and automatic. See the high-performance computing guide for all the details.

# Use the spare cores on your local machine.
make(plan, jobs = 4)

# Or scale up to a supercomputer.
drake_hpc_template_file("slurm_clustermq.tmpl") # https://slurm.schedmd.com/
options(
  clustermq.scheduler = "clustermq",
  clustermq.template = "slurm_clustermq.tmpl"
)
make(plan, parallelism = "clustermq", jobs = 4)

Installation

You can choose among different versions of drake. The CRAN release often lags behind the online manual but may have fewer bugs.

# Install the latest stable release from CRAN.
install.packages("drake")

# Alternatively, install the development version from GitHub.
install.packages("devtools")
library(devtools)
install_github("ropensci/drake")

Function reference

The reference section lists all the available functions. Here are the most important ones.

  • drake_plan(): create a workflow data frame (like my_plan).
  • make(): build your project.
  • drake_history(): show what you built, when you built it, and the function arguments you used.
  • r_make(): launch a fresh callr::r() process to build your project. Called from an interactive R session, r_make() is more reproducible than make().
  • loadd(): load one or more built targets into your R session.
  • readd(): read and return a built target.
  • drake_config(): create a master configuration list for other user-side functions.
  • vis_drake_graph(): show an interactive visual network representation of your workflow.
  • recoverable(): Which targets can we salvage using make(recover = TRUE) (experimental).
  • outdated(): see which targets will be built in the next make().
  • deps(): check the dependencies of a command or function.
  • failed(): list the targets that failed to build in the last make().
  • diagnose(): return the full context of a build, including errors, warnings, and messages.

Documentation

Use cases

The official rOpenSci use cases and associated discussion threads describe applications of drake in action. Here are some more applications of drake in real-world projects.

Help and troubleshooting

The following resources document many known issues and challenges.

If you are still having trouble, please submit a new issue with a bug report or feature request, along with a minimal reproducible example where appropriate.

The GitHub issue tracker is mainly intended for bug reports and feature requests. While questions about usage etc. are also highly encouraged, you may alternatively wish to post to Stack Overflow and use the drake-r-package tag.

Contributing

Development is a community effort, and we encourage participation. Please read CONTRIBUTING.md for details.

Similar work

drake enhances reproducibility and high-performance computing, but not in all respects. Literate programming, local library managers, containerization, and strict session managers offer more robust solutions in their respective domains. And for the problems drake does solve, it stands on the shoulders of the giants that came before.

Pipeline tools

GNU Make

The original idea of a time-saving reproducible build system extends back at least as far as GNU Make, which still aids the work of data scientists as well as the original user base of complied language programmers. In fact, the name “drake” stands for “Data Frames in R for Make”. Make is used widely in reproducible research. Below are some examples from Karl Broman’s website.

Whereas GNU Make is language-agnostic, drake is fundamentally designed for R.

  • Instead of a Makefile, drake supports an R-friendly domain-specific language for declaring targets.
  • Targets in GNU Make are files, whereas targets in drake are arbitrary variables in memory. (drake does have opt-in support for files via file_out(), file_in(), and knitr_in().) drake caches these objects in its own storage system so R users rarely have to think about output files.

Remake

remake itself is no longer maintained, but its founding design goals and principles live on through drake. In fact, drake is a direct reimagining of remake with enhanced scalability, reproducibility, high-performance computing, visualization, and documentation.

Factual’s Drake

Factual’s Drake is similar in concept, but the development effort is completely unrelated to the drake R package.

Other pipeline tools

There are countless other successful pipeline toolkits. The drake package distinguishes itself with its R-focused approach, Tidyverse-friendly interface, and a thorough selection of parallel computing technologies and scheduling algorithms.

Memoization

Memoization is the strategic caching of the return values of functions. It is a lightweight approach to the core problem that drake and other pipeline tools are trying to solve. Every time a memoized function is called with a new set of arguments, the return value is saved for future use. Later, whenever the same function is called with the same arguments, the previous return value is salvaged, and the function call is skipped to save time. The memoise package is the primary implementation of memoization in R.

Memoization saves time for small projects, but it arguably does not go far enough for large reproducible pipelines. In reality, the return value of a function depends not only on the function body and the arguments, but also on any nested functions and global variables, the dependencies of those dependencies, and so on upstream. drake tracks this deeper context, while memoise does not.

Literate programming

Literate programming is the practice of narrating code in plain vernacular. The goal is to communicate the research process clearly, transparently, and reproducibly. Whereas commented code is still mostly code, literate knitr / R Markdown reports can become websites, presentation slides, lecture notes, serious scientific manuscripts, and even books.

knitr and R Markdown

drake and knitr are symbiotic. drake’s job is to manage large computation and orchestrate the demanding tasks of a complex data analysis pipeline. knitr’s job is to communicate those expensive results after drake computes them. knitr / R Markdown reports are small pieces of an overarching drake pipeline. They should focus on communication, and they should do as little computation as possible.

To insert a knitr report in a drake pipeline, use the knitr_in() function inside your drake plan, and use loadd() and readd() to refer to targets in the report itself. See an example here.

Version control

drake is not a version control tool. However, it is fully compatible with git, svn, and similar software. In fact, it is good practice to use git alongside drake for reproducible workflows.

However, data poses a challenge. The datasets created by make() can get large and numerous, and it is not recommended to put the .drake/ cache or the .drake_history/ logs under version control. Instead, it is recommended to use a data storage solution such as DropBox or OSF.

Containerization and R package environments

drake does not track R packages or system dependencies for changes. Instead, it defers to tools like Docker, Singularity, renv, and packrat, which create self-contained portable environments to reproducibly isolate and ship data analysis projects. drake is fully compatible with these tools.

workflowr

The workflowr package is a project manager that focuses on literate programming, sharing over the web, file organization, and version control. Its brand of reproducibility is all about transparency, communication, and discoverability. For an example of workflowr and drake working together, see this machine learning project by Patrick Schratz (source).

Acknowledgements

Special thanks to Jarad Niemi, my advisor from graduate school, for first introducing me to the idea of Makefiles for research. He originally set me down the path that led to drake.

Many thanks to Julia Lowndes, Ben Marwick, and Peter Slaughter for reviewing drake for rOpenSci, and to Maëlle Salmon for such active involvement as the editor. Thanks also to the following people for contributing early in development.

Credit for images is attributed here.

Copy Link

Version

Install

install.packages('drake')

Monthly Downloads

1,590

Version

7.5.2

License

GPL-3

Issues

0

Pull Requests

0

Stars

1,340

Forks

129

Maintainer

Landau William

Last Published

July 21st, 2019

Functions in drake (7.5.2)

cache_namespaces

Deprecated. List all the storr cache namespaces used by drake.
clean_main_example

Deprecated: clean the main example from drake_example("main")
clean_mtcars_example

Clean the mtcars example from drake_example("mtcars")
cache_path

Deprecated. Return the file path where the cache is stored, if applicable.
default_Makefile_command

Deprecated
default_Makefile_args

Deprecated
cmq_build

Build a target using the clustermq backend
default_verbose

Deprecated
cleaned_namespaces

Deprecated utility function
check_plan

Deprecated. Check a workflow plan data frame for obvious errors.
clean

Remove targets/imports from the cache.
default_short_hash_algo

Deprecated. Return the default short hash algorithm for make().
default_system2_args

Defunct function
build_times

List the time it took to build each target.
dataset_wildcard

Show the dataset wildcard used in plan_analyses() and plan_summaries().
built

Deprecated. List all the built targets (non-imports) in the cache.
configure_cache

Deprecated. Configure the hash algorithms, etc. of a drake cache.
debug_and_run

Run a function in debug mode.
diagnose

Get diagnostic metadata on a target.
deps_targets

Deprecated.
default_parallelism

Deprecated
cached

List targets in the cache.
default_recipe_command

Deprecated
analyses

Defunct function
dependency_profile

Deprecated in favor of deps_profile().
drake-package

drake: A pipeline toolkit for reproducible computation at scale.
drake_batchtools_tmpl_file

Deprecated. Get a template file for execution on a cluster.
do_prework

Do the prework in the prework argument to make().
doc_of_function_call

Defunct function
deps_profile

Find out why a target is out of date.
deprecate_wildcard

Defunct function
dataframes_graph

Defunct function
check

Defunct function
code_to_plan

Turn an R script file or knitr / R Markdown report into a drake workflow plan data frame.
default_graph_title

Return the default title for graph visualizations
default_long_hash_algo

Deprecated. Return the default long hash algorithm for make().
config

Defunct function
deps_code

List the dependencies of a function or command
deps

Defunct function
drake_envir

Get the environment where drake builds targets
drake_example

Download and save the code and data files of an example drake-powered project.
deps_target

List the dependencies of a target
deps_knitr

Find the drake dependencies of a dynamic knitr report target.
drake_plan_source

Show the code required to produce a given workflow plan data frame
drake_plan

Create a workflow plan data frame for the plan argument of make().
drake_get_session_info

Return the sessionInfo() of the last call to make().
drake_build

Build/process a single target or import.
drake_examples

List the names of all the drake examples.
drake_ggraph

Show a ggraph/ggplot2 representation of your drake project.
drake_cache

Get the cache of a drake project.
drake_config

Create the internal runtime parameter list used internally in make().
drake_debug

Run a single target's command in debug mode.
drake_hpc_template_file

Write a template file for deploying work to a cluster / job scheduler.
drake_hpc_template_files

List the available example template files for deploying work to a cluster / job scheduler.
eager_load_target

Load a target right away (internal function)
evaluate

Defunct function
file_out

Declare output files and directories.
drake_gc

Do garbage collection on the drake cache.
drake_meta

Deprecated. Compute the initial pre-build metadata of a target or import.
drake_session

Deprecated. Return the sessionInfo() of the last call to make().
drake_quotes

Put quotes around each element of a character vector.
drake_tip

Deprecated. Output a random tip about drake.
file_store

Tell drake that you want information on a file (target or import), not an ordinary object.
future_build

Task passed to individual futures in the "future" backend
drake_palette

Deprecated. Show drake's color palette.
drake_cache_log

Get a table that represents the state of the cache.
drake_cache_log_file

Deprecated. Generate a flat text log file to represent the state of the cache.
gather

Defunct function
drake_graph_info

Create the underlying node and edge data frames behind vis_drake_graph().
drake_history

History and provenance
drake_slice

Take a strategic subset of a dataset.
find_cache

Search up the file system for the nearest drake cache.
drake_strings

Turn valid expressions into character strings.
find_knitr_doc

Defunct function
drake_unquote

Remove leading and trailing escaped quotes from character strings.
failed

List failed targets. to make().
is_function_call

Defunct function
isolate_example

Isolate the side effects of an example.
file_in

Declare input files and directories.
expand_plan

Deprecated: create replicates of targets.
example_drake

Defunct function
evaluate_plan

Deprecated: use wildcard templating to create a workflow plan data frame from a template data frame.
ignore

Ignore code
get_cache

Deprecated: the default cache of a drake project.
parallelism_choices

Deprecated
make_with_config

deprecated
manage_memory

Manage the in-memory dependencies of a target.
read_drake_plan

Deprecated
plan

Defunct function
show_source

Show how a target/import was produced.
read_drake_meta

Defunct function
expose_imports

Expose all the imports in a package so make() can detect all the package's nested functions.
make

Run your project (build the outdated targets).
long_hash

Deprecated. drake now has just one hash algorithm per cache.
this_cache

Get the cache at the exact file path specified.
static_drake_graph

Deprecated: show a ggraph/ggplot2 representation of your drake project.
tracked

List the targets and imports that are reproducibly tracked.
gather_plan

Deprecated: write commands to combine several targets into one or more overarching targets.
gather_by

Deprecated: gather multiple groupings of targets
missed

Report any import objects required by your drake_plan plan but missing from your workspace or file system.
migrate_drake_project

Defunct function
legend_nodes

Create the nodes data frame used in the legend of the graph visualizations.
load_basic_example

Defunct function
examples_drake

Defunct function
max_useful_jobs

Defunct function
map_plan

Deprecated: create a plan that maps a function to a grid of arguments.
plan_drake

Defunct function
r_make

Reproducible R session management for drake functions
r_recipe_wildcard

deprecated
plan_analyses

Deprecated.
expand

Defunct function
load_main_example

Deprecated: load the main example.
load_mtcars_example

Load the mtcars example.
render_graph

Defunct function
plan_to_code

Turn a drake workflow plan data frame into a plain R script file.
plan_summaries

Deprecated
rate_limiting_times

Defunct function
render_sankey_drake_graph

Render a Sankey diagram fromdrake_graph_info().
read_drake_seed

Read the pseudo-random number generator seed of the project.
read_config

Defunct function
read_graph

Defunct function
in_progress

Deprecated. List the targets that either (1) are currently being built during a make(), or (2) were being built if the last make() quit unexpectedly.
imported

Deprecated. List all the imports in the drake cache.
make_imports

deprecated
make_targets

deprecated
plan_to_notebook

Turn a drake workflow plan data frame into an R notebook,
plot_graph

Defunct function
process_import

internal function
recoverable

List the most upstream recoverable outdated targets.
recover_cache

Deprecated. Load an existing drake files system cache if it exists or create a new one otherwise.
predict_workers

Predict the load balancing of the next call to make() for non-staged parallel backends.
knitr_in

Declare knitr/rmarkdown source files as dependencies.
prune_drake_graph

deprecated
knitr_deps

Deprecated in favor of deps_knitr()
progress

Get the build progress of your targets during a make().
read_plan

Defunct function
render_text_drake_graph

Render a text-based visualization of drake's dependency graph using the data frames generated by drake_graph_info().
render_static_drake_graph

Deprecated: render a ggraph/ggplot2 representation of your drake project.
rs_addin_r_make

RStudio addin for r_make()
short_hash

Deprecated. drake now only uses one hash algorithm per cache.
reduce_plan

Deprecated: write commands to reduce several targets down to one.
shell_file

Deprecated
transform_plan

Transform a plan
reduce_by

Deprecated: reduce multiple groupings of targets
find_project

Deprecated. Search up the file system for the nearest root path of a drake project.
from_plan

Defunct function.
running

List running targets.
type_sum.expr_list

Type summary printing
triggers

Deprecated. List the old drake triggers.
rs_addin_r_vis_drake_graph

RStudio addin for r_vis_drake_graph()
trigger

Customize the decision rules for rebuilding targets
use_drake

Use drake in a project
workflow

Defunct function
rs_addin_r_outdated

RStudio addin for r_outdated()
vis_drake_graph

Show an interactive visual network representation of your drake project.
readd

Read and return a drake target/import from the cache.
render_drake_graph

Render a visualization using the data frames generated by drake_graph_info().
session

Defunct function
sankey_drake_graph

Show a Sankey graph of your drake project.
render_drake_ggraph

Render a static ggplot2/ggraph visualization from drake_graph_info() output.
workplan

Defunct function
text_drake_graph

Use text art to show a visual representation of your workflow's dependency graph in your terminal window.
target_namespaces

Deprecated. For drake caches, list the storr cache namespaces that store target-level information.
new_cache

Make a new drake cache.
no_deps

Suppress dependency detection.
predict_runtime

Predict the elapsed runtime of the next call to make() for non-staged parallel backends.
parallel_stages

Defunct function
predict_load_balancing

Deprecated in favor of predict_workers()
outdated

List the targets that are out of date.
read_drake_config

Deprecated
read_drake_graph

Deprecated
rescue_cache

Try to repair a drake cache that is prone to throwing storr-related errors.
summaries

Defunct function
rs_addin_loadd

Loadd target at cursor into global environment
target

Define custom columns in a drake_plan().
backend

Defunct function
bind_plans

Row-bind together drake plans
Makefile_recipe

Deprecated
analysis_wildcard

Deprecated. Show the analysis wildcard used in plan_summaries().
as_file

Defunct function
as_drake_filename

Defunct function
available_hash_algos

Deprecated. List the available hash algorithms for drake caches.
build_graph

Defunct function
build_drake_graph

Deprecated function build_drake_graph