pixi_upgrade() leaves R as it is, unless r = TRUE (or "r-base" is
named): upgrading everything used to take a project to a new version of R,
for which conda-forge has fewer packages. In an interactive session,
pixi_update() and pixi_upgrade() show what would change, and ask before
going ahead. Afterwards they install the environment, as pixi update
doesn't; in the project's own R they say to restart it (and offer to, in
RStudio), and on Windows only update pixi.lock, as a running R keeps
Pixi from replacing its packages' files (#200).use_pixi_jupyter(), and use_pixi(ide = "jupyter"), set the project up
for Jupyter notebooks: a kernel for each environment with R, which starts
that environment's R through pixi run, JupyterLab in an environment of its
own, and a jupyter task that starts it with those kernels. Experimental.
See the IDE guide (#184).use_pixi_python(), and use_pixi(python = TRUE), add Python to the
project's environment for reticulate, and point reticulate at it, and
pixi_add("pypi::pydytuesday") adds Python packages from PyPI. Both are
experimental. See Python alongside R (#108).pixi_add_environment(r_version = ) adds an environment with another
version of R in one step: R, the project's packages (so it gets the versions
built for that R), rpix and the isolation from your personal library, and
installs it. If that R can't have the packages, pixi.toml is left as it
was. pixi_add_environment() without features says the environment is a
copy of the default one, and pixi_add(feature = ) for a feature no
environment uses says how to add one (#201).pixi_sitrep() lists files that more than one package in an environment
installs, such as shared libraries, and whose copy is there: only one can
be, so the other package may not work. It says when it's Strawberry Perl's
MinGW runtime over conda-forge's, which on Windows stops compiled R
packages from loading, and how to find what brings perl in (#176, #177).pixi global install
can install (Emacs, Neovim, Zed and direnv). use_pixi_emacs(),
use_pixi_neovim(), use_pixi_zed(), and use_pixi_vscode() on Windows,
link to it when the editor's command isn't on the PATH (#193).pixi.toml, and the sitrep. A New Project template, "Project with Pixi",
sets up a project as use_pixi(ide = "rstudio") does, for the version of
R picked there, optionally as a git repository. In
RStudio, when the project opens in an R that isn't its Pixi R, rpix offers
to reopen it in a new RStudio with that R (#137, #143).pixi_sitrep(), rpix says when a project also has renv,
e.g. because RStudio's New Project set it up, as renv and Pixi clash, and
that pixi_import_renv() turns renv off.pixi_add(type = ) and pixi_remove(type = ) also add packages to, or
remove them from, a field of the package's DESCRIPTION, such as
"Imports" or "Suggests", as usethis::use_package() does. A >=
constraint becomes the minimum version there, and packages from GitHub go
in Remotes too. type = "SystemRequirements" adds conda packages there
under conda-forge's names, e.g. pixi_add("conda::gdal", type = "SystemRequirements"). The rest of DESCRIPTION stays as it is (#256).DESCRIPTION comes to
need packages that pixi.toml doesn't have, e.g. after
usethis::use_package() or an edit, and in an interactive session offers to
add them with pixi_import_description(). It also says when DESCRIPTION
no longer lists a package. options(rpix.watch_description = FALSE) turns
it off (#255).use_pixi() notices a project that uses renv (renv.lock), and in an
interactive session offers to move its packages over with
pixi_import_renv(), which also turns renv off. Coming from renv now
moves a project with use_pixi(path = ) from your usual R, rather than
with commands in a terminal (#252).rlang::check_installed() does: setting up a
project where there's none (with use_pixi()), logging in to a channel
that refused access and trying again, adding the packages pixi_scan()
finds, updating the packages after pixi_set_date(NULL), adding VS Code's
console (arf or radian) when pixi_switch() finds it missing, adding
linux-64 for use_pixi_github_action(), and using the newest R conda-forge
has packages for when use_pixi() asks for a newer one (#251).pixi_remove_channel() and pixi_remove_platform() remove channels and
platforms from the project, as pixi_add_channel() and
pixi_add_platform() add them (#254).pixi_install(locked = TRUE) fails if pixi.lock is out of date with
pixi.toml, and pixi_install(frozen = TRUE) installs pixi.lock without
checking it, as pixi install --locked and --frozen do (#253).options(rpix.ref) makes use_pixi() also install rpix into the
environment from GitHub, at a branch, tag or commit (e.g. "main", or a
pull request's branch), to try a change before it's released. The installed
rpix records the commit, so use_pixi() reinstalls only when it changes
(#245).use_pixi_emacs(), use_pixi_neovim() and use_pixi_zed() set up those
editors, and use_pixi(ide = ) takes them too. They add languageserver,
and a .envrc from the new use_pixi_direnv(), which activates the
project's environment with direnv. pixi_switch() and pixi_sitrep()
know them (#185, #186, #187).use_pixi_positron() makes the default environment's R Positron's default
for the project, so Positron (2026.10 or later) starts it when the project
opens, without picking it first. default_r = FALSE leaves it out (#133).use_pixi_vscode(console = ) sets up arf or radian as the R extension's
console, starting the environment's R. pixi_switch() keeps the console
(#132).use_pixi_vscode() asks which console to use.
use_pixi(ide = ) passes the IDEs' settings on, e.g.
use_pixi(ide = "vscode", console = "arf") (#134).pixi_switch() without an environment asks
which, from a menu of the project's environments (#189).use_pixi() turns on Pixi's activation cache for the project, so R started
through Pixi, e.g. by pixi run R or Positron, starts in a fraction of a
second rather than a few. activation_cache = FALSE leaves it off (#195).options(rpix.verbose = TRUE) shows the output and build logs of Pixi
that rpix keeps back, as they come (#222)..Rprofile says so, with
the command that installs it. use_pixi() updates the .Rprofile of a
project set up earlier (#216).use_pixi(ide = ),
before pixi run R.rpix::, so the code they suggest
runs as shown, as rpix usually isn't attached (#251).SystemRequirements now says. It's
the first Pixi that can build packages with pixi-build-r 0.2.0, for
github:: packages and CRAN packages that aren't on conda-forge. A CI job
checks rpix with it (#84).pixi_add(), pixi_remove(), pixi_search(),
pixi_install(), the environment, channel and task functions,
use_pixi_direnv(), use_pixi_positron() and pixi_sitrep() run without
Pixi: they set up a throwaway project in R's temporary folder, and show the
Pixi commands with dry_run = TRUE (#84).r-rpix), so it's in pixi.lock and
a collaborator's environment has it, rather than installed into the
environment from R-universe. It isn't on conda-forge yet: until it is,
use_pixi() adds the channel rpix-forge,
after conda-forge, which also has the R extension's sess and jgd for VS Code.
Everything else still comes from conda-forge. The .Rprofile hint for an
environment without rpix gives the Pixi commands that add it.install.packages() of a package already in
pixi.toml says so, and how to update it with pixi_update(), rather than
passing on Pixi's "already a dependency" (#210).use_pixi() creates a project for Linux, macOS (Intel and Apple Silicon)
and Windows, and your computer's platform if it's another one, so
collaborators on any of them can install it; platforms chooses others.
Before, a project only had the platform it was created on (#215).use_pixi_rstudio() adds the rstudio task for all four of those
platforms, whichever the project has; Pixi adds any it doesn't (#215).pixi-build-r 0.2.0 or later, which rpix
now asks for. It adds Rust, CMake, pkg-config and R's recommended packages,
and installs into R's library on Windows, so rpix no longer does (#148,
#149, #150, #152). rpix still adds Java, and on Windows, MSYS2's tools and
MinGW's compilers. A project with packages as of a date before 2026-10-15
can't get that pixi-build-r, so rpix stops and says so.use_pixi_vscode() and pixi_switch() also give the commands
that start VSCodium, Cursor and Windsurf from the environment, and the IDE
guide says the VS Code setup works in them too.PIXI_WORKSPACE_ROOT, as Pixi 0.82 names it, and otherwise from
PIXI_PROJECT_ROOT, which Pixi keeps as an alias and older versions set.pixi_switch() and pixi_check_matrix() say when they install an
environment for the first time, which can take a while, and show Pixi's
output, rather than waiting in silence. pixi_check_matrix() now installs
before the run, so its time doesn't include the install (#223).use_pixi() and the IDE setups only add the packages the project doesn't
have yet, rather than having Pixi say of each of the others that it's
there, and use_pixi(ide = ) sets direnv up once for several editors, so
running them again, or for several IDEs, says each thing once (#222).pixi_add(), and install.packages() in a Pixi environment, show Pixi's
output once the packages are added. When Pixi can't add them but rpix can,
e.g. from bioconda or by building from source, Pixi's error isn't shown;
when rpix can't, all of Pixi's output is (#222).use_pixi() installs rpix into the environment quietly, and only if the
environment doesn't have this version or a newer one (#222).pixi_add() says so, and for which, rather than that it couldn't be found
(#215).pixi_import_renv() adds only the packages the project uses from lock
files written by renv 1.1 or later too, which record what each package
needs differently; it added every package in them (#206).install.packages() accepts repos, and adds the
packages with Pixi as usual. Package files and folders (repos = NULL) go
to utils::install.packages(), which pixi.toml doesn't record. VS Code's
R extension can now install its sess package (#209).use_pixi_vscode(), and use_pixi(ide = "vscode"), add the R extension's
sess and jgd (from rpix-forge, see Changed). Version 3.2 of the extension
installed sess's dependencies from CRAN, past rpix's install.packages(),
and later needs a compiler the environment doesn't have, so it couldn't
start an R Interactive session. r-sess brings them from conda-forge, and is
built from the extension's release, so the extension uses it as it is
(#244).use_pixi() sets up the folder it's given, or the working directory, rather
than a Pixi project in a parent folder. It says when a parent folder is a
Pixi project, and in an interactive session asks whether to set that one up
instead (#214).pixi_sitrep() no longer says the package itself was
installed without Pixi, e.g. after devtools::install() (#220).pixi_add(), pixi_remove() and
install.packages() install the environment R runs in, as Pixi doesn't by
itself there; a package added was missing until the next pixi install
(#202).configure script build: rpix
gives their builds MinGW's compilers, which R uses there, in place of
pixi-build-r's, whose Fortran compiler broke the script's checks
(#191).pixi_sitrep()
says how to start the project's R in it, e.g. pixi run rstudio for
RStudio, rather than that the IDE is set up. It no longer lists R's base
packages as loaded from outside the project, and knows Emacs, Neovim and
Zed when it's in none of the IDEs (#219).pixi_add() no longer
change the original project. When the running Pixi environment says it's
from another project than the working directory's, as Pixi's activation
cache can after a copy or move, rpix uses the working directory's project,
and says so (#218).use_pixi() turns on, keeps the old paths, so rpix
removes it when it has another location, before Pixi uses it, and says the
project was moved or copied. pixi_activate() and pixi_sitrep() also
name environments that were installed in the old location, which can't be
moved, and say how to reinstall them (#217).use_pixi(install_rpix = FALSE) picks the newest R it has packages for,
rather than one no package can be added to; use_pixi(r_version = ) with
that R says so, and which R is the newest you can use; and
pixi_import_renv() with a lock file from that R uses the newest R the
packages are built for, and says so (#207).pixi_add() names it,
also when it has a version constraint, and suggests a command that's valid
R and replaces the project's R rather than adding a second one. For an old
version pinned with == or =, which conda-forge won't build for a newer
R, it offers a newer version, a build of that version from source, or the
older R for the whole project (#208).pixi_add() and install.packages() only offer to build a package from
CRAN's source when it's on CRAN. A mistyped name, such as "dplyrr", says
it's on neither conda-forge nor CRAN, and suggests close names: "Did you
mean dplyr?" (#212).DESCRIPTION
(#213).pixi_remove() and pixi_search() take a Bioconductor package's name
without bioc::, as pixi_add() does: pixi_remove("limma") removes
bioconductor-limma when that's what pixi.toml has, and
pixi_search("limma") looks on bioconda when it isn't on conda-forge
(#211).pixi_add() offers to build a CRAN package such as faux from source, rather
than failing because Pixi found r-fauxpas, and pixi_search("faux") no
longer shows r-fauxpas (#205).pixi_add()
and pixi_import_renv() no longer offer to build CRAN packages that
aren't on conda-forge from source, which then failed: they say that the
date hides Pixi's build backend instead (#221).pixi_set_date() and use_pixi(date = ) use packages as they were on a
date, with Pixi's exclude-newer, e.g. to rerun an old analysis; a duration
such as "7d" leaves out the newest releases instead. pixi_sitrep()
reports it (#106).use_pixi_check_matrix(minimum = TRUE) adds a minimum environment, with
R and the package's dependencies at the lowest versions its DESCRIPTION
allows, to check that those minimums really work. It has the Suggests too,
for the tests and examples; those without a minimum get at least the
version the project has (#112, #168).use_pixi_github_action() writes a GitHub Actions workflow that uses the
project's environments exactly as pixi.lock records them: R CMD check
on Linux, macOS and Windows for each environment, test coverage, a pkgdown
site, or a Pixi task. It uses the environments that have what the workflow
needs, such as the check matrix's for R CMD check, and says how to add
what an environment lacks (#107, #159).pixi_sitrep() checks that pixi.toml has what
DESCRIPTION needs: the Depends, Imports and LinkingTo packages in
the default environment, the Suggests somewhere, and installed versions at
least the minimums DESCRIPTION asks for (#113).pixi_import_renv() adds the lock file's GitHub packages, built from source
at the commit it records, and offers to build CRAN packages that aren't on
conda-forge from CRAN's source, as pixi_add() does. As building from
source is experimental, it says which packages it built (#162).skills/rpix/, teaches coding agents such as Claude
Code, Codex and Cursor to work in R projects the Pixi way: add packages with
pixi_add() rather than install.packages(), run the environment's R, and
start from pixi_sitrep() when something's off. In Claude Code, install it
with /plugin marketplace add roaldarbol/rpix and
/plugin install rpix@rpix (#155).make, sed
and coreutils (and, for Rust, the GNU target), which pixi-build-r doesn't
yet (#123).pixi_add("github::..."), and CRAN packages that
aren't on conda-forge) get what pixi-build-r doesn't add yet: R's
recommended packages they use, such as Matrix and MASS, and the build tools
their SystemRequirements names: Rust, Java, CMake or pkg-config (#118).pixi_add_environment(default_feature = FALSE) adds
conda-ecosystem-user-package-isolation to an environment with R, which
keeps the personal R library out, as use_pixi() does for the default
feature. Before, such an environment, e.g. with another version of R, could
load packages built for another R, and crash. pixi_add() adds it too when
it adds R to the default feature without it, and pixi_sitrep() reports
environments with R that lack it, e.g. after editing pixi.toml by hand
(#160).pixi_add(), pixi_install(), pixi_update() and pixi_upgrade() notice
when Pixi skips a package's install script, which Bioconductor's annotation
and data packages (such as org.Hs.eg.db) use to download their data. They
offer to allow these scripts in the project, and otherwise warn. Before,
such packages were added without their data, and didn't load. Committing
.pixi/config.toml allows the scripts for everyone who uses the project,
CI included (#142, #158).pixi.toml; Pixi couldn't read them before (#120).use_pixi() adds .pixi, pixi.toml and pixi.lock to
.Rbuildignore, and the IDE setup adds .vscode, so they stay out of the
package's builds. pixi_sitrep() reports them when they're missing (#114).install_pixi() installs Pixi with Pixi's official installer (#87). When a
function can't find Pixi, rpix offers to install it.
pixi_auth_login(), pixi_auth_logout() and pixi_auth_status() log in to
private conda channels, e.g. on prefix.dev, anaconda.org, Artifactory or S3
(experimental; #93, #97). pixi_auth_login() asks for the token or password
without showing it, and rpix shows <hidden> wherever it would appear.
When a channel refuses access, rpix's errors and pixi_sitrep() say which host
refused and suggest pixi_auth_login(), and pixi_sitrep() lists the hosts
Pixi has logins for (#95).
pixi_add() adds R packages from GitHub, built from source by Pixi's R build
backend, pixi-build-r (experimental; #88, #96):
pixi_add("github::user/repo")
pixi_add("github::cran/praise", versions = "1.0.0")
@ref or versions picks a branch, tag or commit. pixi_remove() removes
them the same way.
When pixi_add() can't find a CRAN package on conda-forge, it offers to build
it from CRAN's GitHub mirror, or, in a script, says how (experimental; #89,
#96).
New guide: "Private channels and company networks" (#95).
pixi_add() finds Bioconductor packages on bioconda without the bioc::
prefix, e.g. pixi_add("DESeq2") or pixi_add("DESeq2", channel = "bioconda")
(#92).install.packages() offers to build packages that
aren't on conda-forge from source, like pixi_add(), instead of pointing to
utils::install.packages() (#91).add() and setup_pixi(), deprecated since 0.4.0 and 0.5.0. Use pixi_add()
and use_pixi() (#85).use_pixi() show their message again, rather
than "there is no package called 'rlang'" (#98).pixi_switch() moves your work to another environment's R (#32). In RStudio
it starts a new RStudio with that R; in Positron it looks for interpreters
again and opens the interpreter picker; in VS Code it points the R extension
at that R.pixi_r() runs a function in another environment's R, e.g. one with another
version of R, and returns its result (#33).pixi_check_matrix() runs a package's tests or R CMD check in several
environments, one at a time or all at once, and shows the results side by
side. use_pixi_check_matrix() adds an environment for each version of R
(#34).pixi_import_renv() moves a project from renv: it adds the packages in
renv.lock that nothing else in it needs, at least at their locked versions
or exactly, lists those it can't add, and turns renv off (#37).pixi_import_description() adds a package's Depends and Imports to the
project, and its Suggests to a test environment, finding Bioconductor
packages on bioconda (#36).pixi_scan() finds the packages the project's code uses, in .R files, the R
chunks of .qmd and .Rmd documents and Pixi tasks, lists those missing from
pixi.toml (and adds them with add = TRUE), and lists packages the code
never uses (#38).pixi_tasks(), pixi_run(), pixi_add_task() and pixi_remove_task() work
with the project's Pixi tasks (#35).install.packages() adds packages with
pixi_add(), so they're recorded in pixi.toml and pixi.lock (#3). Turn it
off with options(rpix.install_packages = FALSE).pixi_sitrep() lists packages in the environment that Pixi didn't install
(#3).pixi_add() explains when a package isn't built for the project's version of
R yet, and suggests the newest R it's built for (#80).use_pixi() adds R together with the packages it needs, so Pixi picks the
newest R they're built for (#72).pixi_tasks(), pixi_environments(), pixi_list() and pixi_info() print
their results in a readable form (#67). They're still data frames, or a list
for pixi_info().use_pixi_rstudio() replaces the rstudio task if it's there, so it can be
run again (#72).restart_rstudio_with_pixi(). Use pixi_switch(), or start RStudio with
pixi run rstudio (#32).use_pixi() sets a project up, with R, rpix and its dependencies (#26). Its
ide argument sets the project up for an IDE (#27):
use_pixi_rstudio() adds an rstudio task, so pixi run rstudio starts a
new RStudio with the environment's R, in the project.use_pixi_positron() turns on Positron's discovery of R in Pixi
environments.use_pixi_vscode() adds languageserver, and points the R extension for VS
Code and VSCodium at the environment's R.pixi_activate() activates the project's Pixi environment in R that an IDE
started directly (#25). use_pixi() adds a block to the project's
.Rprofile that calls it.pixi_environments(), pixi_add_environment() and
pixi_remove_environment() manage a project's environments, and pixi_add()
and pixi_remove() gain feature and platform arguments (#30).pixi_add_channel(), pixi_add_platform(), pixi_install(),
pixi_update(), pixi_upgrade() and pixi_lock() (#30).pixi_sitrep() checks the project's Pixi setup, and suggests fixes (#28).pixi_info(), pixi_list() and pixi_tree() (#29). pixi_list() returns
an environment's packages as a data frame, with each R package's name as R
spells it.pixi_add(), pixi_remove(), pixi_search() and use_pixi() gain a path
argument.use_pixi() keeps your personal R library out of the environment's R, by
adding conda-forge's conda-ecosystem-user-package-isolation
(conda-forge/r-base-feedstock#37).setup_pixi(). Use use_pixi() (#26)."Rcpp" becomes
r-rcpp, "bioc::DESeq2" a Bioconductor package from bioconda (#17), and
"conda::gdal" a conda package that isn't an R package.pixi_add() takes version constraints inline ("dplyr>=1.1"), and one per
package in versions.pixi_<command>() (#20).
remove() and search() are now pixi_remove() and pixi_search().pixi run R.setup_pixi() only sets up the project: it creates pixi.toml, adds R
(r_version picks the version) and installs rpix. It removes the "Pixi R
library setup" block from the project's .Rprofile, and warns about one in
~/.Rprofile.PATH (#19). Set
options(rpix.pixi_path = ) for unusual installs.dry_run = TRUE, pixi_add(), pixi_remove() and pixi_search()
return the command invisibly.pixi_add() suggests bioc:: and conda:: when a package can't be found.add(). Use pixi_add() (#20).remove() and search(), which masked the base functions. Use
pixi_remove() and pixi_search() (#20).pixi_to_path(). rpix finds Pixi itself (#20).reset_r_libraries(), and setup_pixi()'s add_to_rprofile and global
arguments (#22).pixi_add(channel = ) adds the channel to the project and installs from it.restart_rstudio_with_pixi() restarts RStudio with the project's R.setup_pixi() installs rpix from CRAN into the Pixi environment.setup_pixi() sets up a Pixi project from R.search() searches for packages, their versions and their dependencies.dry_run shows the Pixi command without running it.add() adds several packages at once.