parsnip required_pkgs() in R: Find a Model's Packages

The parsnip required_pkgs() function returns a character vector of every R package needed to fit and predict with a model specification or fitted model. It is how tidymodels knows which packages to load on parallel workers.

required_pkgs(spec)                  # all packages a model spec needs
required_pkgs(spec, infra = FALSE)   # engine package only, drop parsnip
required_pkgs(fitted_model)          # packages for a fitted model object
required_pkgs(linear_reg())          # errors: engine not set
spec |> set_engine("ranger") |> required_pkgs()   # pipe-friendly form
generics::required_pkgs(spec)        # the S3 generic behind the method

What required_pkgs() does

required_pkgs() answers one question: what do I need installed to run this model? You pass a parsnip model specification or a fitted model, and it returns the names of every package that fitting and prediction depend on. The result is a plain character vector, so it slots straight into install.packages() or a dependency check.

The function is an S3 method dispatched on the object class. parsnip registers methods for both model_spec (an unfitted specification) and model_fit (a fitted model). The underlying generic lives in the generics package, which is why recipes, workflows, and tune can all answer the same question for their own object types.

Syntax and arguments

The signature is short. Both methods take the object plus one meaningful argument.

Set infra = FALSE when you only care about the engine package and not the tidymodels plumbing. The model must have an engine assigned with set_engine() first, otherwise the function stops with an error.

required_pkgs() examples

Start with a model specification. Load parsnip, build a spec, and ask for its packages. The glmnet engine pulls in the glmnet package alongside parsnip.

Drop the infrastructure packages with infra = FALSE. This leaves only the engine package, which is handy when you already know tidymodels is installed.

A fitted model can report different packages. Once you fit, the result reflects what prediction actually touches. Here the lm engine adds stats, the base package that powers it.

Compare several engines at once. Because the result is a character vector, lapply() over a list of specs gives a tidy dependency map for a whole modeling workflow.

None of these calls need the engine package installed. required_pkgs() only looks up the registered model definition, so you can audit dependencies before downloading a single package.

required_pkgs() vs related parsnip helpers

required_pkgs() is one of several model-inspection tools. Each answers a different question about a spec or fit.

Reach for required_pkgs() when the question is about dependencies. Reach for translate() when the question is about the call parsnip generates. They complement each other during debugging.

Common pitfalls

Calling it before set_engine() is the most frequent mistake. A bare model spec has no engine, so parsnip cannot know the dependencies.

The fix is to pipe through set_engine() first. Second, remember that required_pkgs() does not check whether packages are installed. It only lists names. To verify availability, pass the result to rlang::is_installed() or wrap it in a requireNamespace() loop.

Third, the default infra = TRUE always includes parsnip. If you feed the output straight into a "missing engine packages" report, switch to infra = FALSE so tidymodels infrastructure does not show up as a dependency you need to chase.

Try it yourself

Related parsnip functions

These functions pair naturally with required_pkgs() when inspecting or debugging a model:

• show_engines() lists every engine available for a model type.
• set_engine() assigns the engine that required_pkgs() reports on.
• translate() reveals the exact engine call parsnip builds.
• extract_fit_engine() returns the raw model object after fitting.
• fit() trains the spec so you can call required_pkgs() on the result.

FAQ

What does required_pkgs() return in R?

It returns a character vector of package names. For a model specification, the vector lists every package needed to fit and predict with that model, including parsnip itself by default. For a fitted model, the vector reflects what prediction touches, which can differ slightly from the spec. The output is ordinary character data, so you can pass it to install.packages() or a dependency check directly.

What is the infra argument in required_pkgs()?

The infra argument controls whether infrastructure packages appear in the result. When infra = TRUE, the default, parsnip and other tidymodels plumbing packages are included. When infra = FALSE, only the engine package is returned, such as glmnet or ranger. Use infra = FALSE when you already know tidymodels is installed and only want to confirm the engine dependency.

Does required_pkgs() install missing packages?

No. The function only reports package names; it never downloads or attaches anything. It also works when the engine package is not installed, because it reads the parsnip model registry rather than your library. To act on the result, pass it to rlang::is_installed() to check availability or to install.packages() to fetch the missing ones.

Why does required_pkgs() say "Please set an engine"?

A parsnip model specification has no engine until you call set_engine(). Without an engine, parsnip cannot look up which package implements the model, so required_pkgs() stops with that error. Fix it by piping the spec through set_engine() before calling required_pkgs(), for example linear_reg() |> set_engine("lm") |> required_pkgs().

How does tidymodels use required_pkgs() for parallel processing?

When the tune package runs tune_grid() or fit_resamples() across multiple workers, each worker is a fresh R process with nothing loaded. tune calls required_pkgs() on the model and recipe to learn which packages every worker needs, then loads them automatically. This is why parallel tidymodels runs usually work without you attaching engine packages by hand.