# processx

> Execute and Control System Processes

Tools to run system processes in the background, read their standard
output and error and kill them.

processx can poll the standard output and error of a single process, or
multiple processes, using the operating system’s polling and waiting
facilities, with a timeout.

------------------------------------------------------------------------

- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)
  - [Running an external process](#running-an-external-process)
    - [Errors](#errors)
    - [Showing output](#showing-output)
    - [Spinner](#spinner)
    - [Callbacks for I/O](#callbacks-for-io)
  - [Managing external processes](#managing-external-processes)
    - [Starting processes](#starting-processes)
    - [Killing a process](#killing-a-process)
    - [Standard output and error](#standard-output-and-error)
    - [End of output](#end-of-output)
    - [Polling the standard output and
      error](#polling-the-standard-output-and-error)
    - [Polling multiple processes](#polling-multiple-processes)
    - [Waiting on a process](#waiting-on-a-process)
    - [Exit statuses](#exit-statuses)
    - [Mixing processx and the parallel base R
      package](#mixing-processx-and-the-parallel-base-r-package)
    - [Errors](#errors-1)
- [Related tools](#related-tools)
- [Code of Conduct](#code-of-conduct)
- [License](#license)

## Features

- Start system processes in the background and find their process id.
- Read the standard output and error, using non-blocking connections
- Poll the standard output and error connections of a single process or
  multiple processes.
- Write to the standard input of background processes.
- Check if a background process is running.
- Wait on a background process, or multiple processes, with a timeout.
- Get the exit status of a background process, if it has already
  finished.
- Kill background processes.
- Kill background process, when its associated object is garbage
  collected.
- Kill background processes and all their child processes.
- Works on Linux, macOS and Windows.
- Lightweight, it only depends on the also lightweight R6 and ps
  packages.

## Installation

Install the stable version from CRAN:

``` r
install.packages("processx")
```

If you need the development version, install it from GitHub:

``` r
pak::pak("r-lib/processx")
```

## Usage

``` r
library(processx)
```

> Note: the following external commands are usually present in macOS and
> Linux systems, but not necessarily on Windows. We will also use the
> `px` command line tool (`px.exe` on Windows), that is a very simple
> program that can produce output to `stdout` and `stderr`, with the
> specified timings.

``` r
px <- paste0(
  system.file(package = "processx", "bin", "px"),
  system.file(package = "processx", "bin", .Platform$r_arch, "px.exe")
)
px
```

``` R
#> [1] "/Users/gaborcsardi/Library/R/arm64/4.5/library/processx/bin/px"
```

### Running an external process

The [`run()`](http://processx.r-lib.org/reference/run.md) function runs
an external command. It requires a single command, and a character
vector of arguments. You don’t need to quote the command or the
arguments, as they are passed directly to the operating system, without
an intermediate shell.

``` r
run("echo", "Hello R!")
```

``` R
#> $status
#> [1] 0
#> 
#> $stdout
#> [1] "Hello R!\n"
#> 
#> $stderr
#> [1] ""
#> 
#> $timeout
#> [1] FALSE
```

Short summary of the `px` binary we are using extensively below:

``` r
result <- run(px, "--help", echo = TRUE)
```

``` R
#> Usage: px [command arg] [command arg] ...
#> 
#> Commands:
#>   sleep  <seconds>           -- sleep for a number os seconds
#>   out    <string>            -- print string to stdout
#>   err    <string>            -- print string to stderr
#>   outln  <string>            -- print string to stdout, add newline
#>   errln  <string>            -- print string to stderr, add newline
#>   errflush                   -- flush stderr stream
#>   cat    <filename>          -- print file to stdout (use '<stdin>' for standard input)
#>   return <exitcode>          -- return with exitcode
#>   writefile <path> <string>  -- write to file
#>   write <fd> <string>        -- write to file descriptor
#>   echo <fd1> <fd2> <nbytes>  -- echo from fd to another fd
#>   getenv <var>               -- environment variable to stdout
#>   rawout <hexstring>         -- write raw bytes (hex pairs) to stdout
#>   rawerr <hexstring>         -- write raw bytes (hex pairs) to stderr
```

> Note: From version 3.0.1, processx does not let you specify a full
> shell command line, as this involves starting a grandchild process
> from the child process, and it is difficult to clean up the grandchild
> process when the child process is killed. The user can still start a
> shell (`sh` or `cmd.exe`) directly of course, and then proper cleanup
> is the user’s responsibility.

#### Errors

By default [`run()`](http://processx.r-lib.org/reference/run.md) throws
an error if the process exits with a non-zero status code. To avoid
this, specify `error_on_status = FALSE`:

``` r
run(px, c("out", "oh no!", "return", "2"), error_on_status = FALSE)
```

``` R
#> $status
#> [1] 2
#> 
#> $stdout
#> [1] "oh no!"
#> 
#> $stderr
#> [1] ""
#> 
#> $timeout
#> [1] FALSE
```

#### Showing output

To show the output of the process on the screen, use the `echo`
argument. Note that the order of `stdout` and `stderr` lines may be
incorrect, because they are coming from two different connections.

``` r
result <- run(px,
  c("outln", "out", "errln", "err", "outln", "out again"),
  echo = TRUE)
```

``` R
#> out
#> out again
#> err
```

If you have a terminal that support ANSI colors, then the standard error
output is shown in red.

The standard output and error are still included in the result of the
[`run()`](http://processx.r-lib.org/reference/run.md) call:

``` r
result
```

``` R
#> $status
#> [1] 0
#> 
#> $stdout
#> [1] "out\nout again\n"
#> 
#> $stderr
#> [1] "err\n"
#> 
#> $timeout
#> [1] FALSE
```

Note that [`run()`](http://processx.r-lib.org/reference/run.md) is
different from [`system()`](https://rdrr.io/r/base/system.html), and it
always shows the output of the process on R’s proper standard output,
instead of writing to the terminal directly. This means for example that
you can capture the output with
[`capture.output()`](https://rdrr.io/r/utils/capture.output.html) or use
[`sink()`](https://rdrr.io/r/base/sink.html), etc.:

``` r
out1 <- capture.output(r1 <- system("ls"))
out2 <- capture.output(r2 <- run("ls", echo = TRUE))
```

``` r
out1
```

``` R
#> character(0)
```

``` r
out2
```

``` R
#>  [1] "_pkgdown.yml"   "codecov.yml"    "DESCRIPTION"    "inst"          
#>  [5] "LICENSE"        "LICENSE.md"     "Makefile"       "man"           
#>  [9] "NAMESPACE"      "NEWS.md"        "processx.Rproj" "R"             
#> [13] "README.md"      "README.Rmd"     "src"            "tests"         
#> [17] "vignettes"
```

#### Spinner

The `spinner` option of
[`run()`](http://processx.r-lib.org/reference/run.md) puts a calming
spinner to the terminal while the background program is running. The
spinner is always shown in the first character of the last line, so you
can make it work nicely with the regular output of the background
process if you like. E.g. try this in your R terminal:

``` R
result <- run(px,
  c("out", "  foo",
    "sleep", "1",
    "out", "\r  bar",
    "sleep", "1",
    "out", "\rX foobar\n"),
  echo = TRUE, spinner = TRUE)
```

#### Callbacks for I/O

[`run()`](http://processx.r-lib.org/reference/run.md) can call an R
function for each line of the standard output or error of the process,
just supply the `stdout_line_callback` or the `stderr_line_callback`
arguments. The callback functions take two arguments, the first one is a
character scalar, the output line. The second one is the `process`
object that represents the background process. (See more below about
`process` objects.) You can manipulate this object in the callback, if
you want. For example you can kill it in response to an error or some
text on the standard output:

``` r
cb <- function(line, proc) {
  cat("Got:", line, "\n")
  if (line == "done") proc$kill()
}
result <- run(px,
  c("outln", "this", "outln", "that", "outln", "done",
    "outln", "still here", "sleep", "10", "outln", "dead by now"), 
  stdout_line_callback = cb,
  error_on_status = FALSE,
)
```

``` R
#> Got: this 
#> Got: that 
#> Got: done 
#> Got: still here
```

``` r
result
```

``` R
#> $status
#> [1] -9
#> 
#> $stdout
#> [1] "this\nthat\ndone\nstill here\n"
#> 
#> $stderr
#> [1] ""
#> 
#> $timeout
#> [1] FALSE
```

Keep in mind, that while the R callback is running, the background
process is not stopped, it is also running. In the previous example,
whether `still here` is printed or not depends on the scheduling of the
R process and the background process by the OS. Typically, it is
printed, because the R callback takes a while to run.

In addition to the line-oriented callbacks, the `stdout_callback` and
`stderr_callback` arguments can specify callback functions that are
called with output chunks instead of single lines. A chunk may contain
multiple lines (separated by `\n` or `\r\n`), or even incomplete lines.

### Managing external processes

If you need better control over possibly multiple background processes,
then you can use the R6 `process` class directly.

#### Starting processes

To start a new background process, create a new instance of the
`process` class.

``` r
p <- process$new("sleep", "20")
```

#### Killing a process

A process can be killed via the `kill()` method.

``` r
p$is_alive()
```

``` R
#> [1] TRUE
```

``` r
p$kill()
```

``` R
#> [1] TRUE
```

``` r
p$is_alive()
```

``` R
#> [1] FALSE
```

Note that processes are finalized (and killed) automatically if the
corresponding `process` object goes out of scope, as soon as the object
is garbage collected by R:

``` r
p <- process$new("sleep", "20")
rm(p)
invisible(gc())
```

Here, the direct call to the garbage collector kills the `sleep` process
as well. See the `cleanup` option if you want to avoid this behavior.

#### Standard output and error

By default the standard output and error of the processes are ignored.
You can set the `stdout` and `stderr` constructor arguments to a file
name, and then they are redirected there, or to `"|"`, and then processx
creates connections to them. (Note that starting from processx 3.0.0
these connections are not regular R connections, because the public R
connection API was retroactively removed from R.)

The `read_output_lines()` and `read_error_lines()` methods can be used
to read complete lines from the standard output or error connections.
They work similarly to the
[`readLines()`](https://rdrr.io/r/base/readLines.html) base R function.

Note, that the connections have a buffer, which can fill up, if R does
not read out the output, and then the process will stop, until R reads
the connection and the buffer is freed.

> **Always make sure that you read out the standard output and/or
> error** **of the pipes, otherwise the background process will stop
> running!**

If you don’t need the standard output or error any more, you can also
close it, like this:

``` r
close(p$get_output_connection())
close(p$get_error_connection())
```

Note that the connections used for reading the output and error streams
are non-blocking, so the read functions will return immediately, even if
there is no text to read from them. If you want to make sure that there
is data available to read, you need to poll, see below.

``` r
p <- process$new(px,
  c("sleep", "1", "outln", "foo", "errln", "bar", "outln", "foobar"),
  stdout = "|", stderr = "|")
p$read_output_lines()
```

``` R
#> character(0)
```

``` r
p$read_error_lines()
```

``` R
#> character(0)
```

#### End of output

The standard R way to query the end of the stream for a non-blocking
connection, is to use the
[`isIncomplete()`](https://rdrr.io/r/base/connections.html) function.
*After a read attempt*, this function returns `FALSE` if the connection
has surely no more data. (If the read attempt returns no data, but
[`isIncomplete()`](https://rdrr.io/r/base/connections.html) returns
`TRUE`, then the connection might deliver more data in the future.

The `is_incomplete_output()` and `is_incomplete_error()` functions work
similarly for `process` objects.

#### Polling the standard output and error

The `poll_io()` method waits for data on the standard output and/or
error of a process. It will return if any of the following events
happen:

- data is available on the standard output of the process (assuming
  there is a connection to the standard output).
- data is available on the standard error of the process (assuming the
  is a connection to the standard error).
- The process has finished and the standard output and/or error
  connections were closed on the other end.
- The specified timeout period expired.

For example the following code waits about a second for output.

``` r
p <- process$new(px, c("sleep", "1", "outln", "kuku"), stdout = "|")

## No output yet
p$read_output_lines()
```

``` R
#> character(0)
```

``` r
## Wait at most 5 sec
p$poll_io(5000)
```

``` R
#>   output    error  process 
#>  "ready" "nopipe" "nopipe"
```

``` r
## There is output now
p$read_output_lines()
```

``` R
#> [1] "kuku"
```

#### Polling multiple processes

If you need to manage multiple background processes, and need to wait
for output from all of them, processx defines a
[`poll()`](http://processx.r-lib.org/reference/poll.md) function that
does just that. It is similar to the `poll_io()` method, but it takes
multiple process objects, and returns as soon as one of them have data
on standard output or error, or a timeout expires. Here is an example:

``` r
p1 <- process$new(px, c("sleep", "1", "outln", "output"), stdout = "|")
p2 <- process$new(px, c("sleep", "2", "errln", "error"), stderr = "|")

## After 100ms no output yet
poll(list(p1 = p1, p2 = p2), 100)
```

``` R
#> $p1
#>    output     error   process 
#> "timeout"  "nopipe"  "nopipe" 
#> 
#> $p2
#>    output     error   process 
#>  "nopipe" "timeout"  "nopipe"
```

``` r
## But now we surely have something
poll(list(p1 = p1, p2 = p2), 1000)
```

``` R
#> $p1
#>   output    error  process 
#>  "ready" "nopipe" "nopipe" 
#> 
#> $p2
#>   output    error  process 
#> "nopipe" "silent" "nopipe"
```

``` r
p1$read_output_lines()
```

``` R
#> [1] "output"
```

``` r
## Done with p1
close(p1$get_output_connection())
```

``` R
#> NULL
```

``` r
## The second process should have data on stderr soonish
poll(list(p1 = p1, p2 = p2), 5000)
```

``` R
#> $p1
#>   output    error  process 
#> "closed" "nopipe" "nopipe" 
#> 
#> $p2
#>   output    error  process 
#> "nopipe"  "ready" "nopipe"
```

``` r
p2$read_error_lines()
```

``` R
#> [1] "error"
```

#### Waiting on a process

As seen before, `is_alive()` checks if a process is running. The
`wait()` method can be used to wait until it has finished (or a
specified timeout expires).. E.g. in the following code `wait()` needs
to wait about 2 seconds for the `sleep` `px` command to finish.

``` r
p <- process$new(px, c("sleep", "2"))
p$is_alive()
```

``` R
#> [1] TRUE
```

``` r
Sys.time()
```

``` R
#> [1] "2025-04-26 09:34:10 CEST"
```

``` r
p$wait()
Sys.time()
```

``` R
#> [1] "2025-04-26 09:34:12 CEST"
```

It is safe to call `wait()` multiple times:

``` r
p$wait() # already finished!
```

#### Exit statuses

After a process has finished, its exit status can be queried via the
`get_exit_status()` method. If the process is still running, then this
method returns `NULL`.

``` r
p <- process$new(px, c("sleep", "2"))
p$get_exit_status()
```

``` R
#> NULL
```

``` r
p$wait()
p$get_exit_status()
```

``` R
#> [1] 0
```

#### Mixing processx and the parallel base R package

In general, mixing processx (via callr or not) and parallel works fine.
If you use parallel’s ‘fork’ clusters, e.g. via
[`parallel::mcparallel()`](https://rdrr.io/r/parallel/mcparallel.html),
then you might see two issues. One is that processx will not be able to
determine the exit status of some processx processes. This is because
the status is read out by parallel, and processx will set it to `NA`.
The other one is that parallel might complain that it could not clean up
some subprocesses. This is not an error, and it is harmless, but it does
hold up R for about 10 seconds, before parallel gives up. To work around
this, you can set the `PROCESSX_NOTIFY_OLD_SIGCHLD` environment variable
to a non-empty value, before you load processx. This behavior might be
the default in the future.

#### Errors

Errors are typically signalled via non-zero exits statuses. The processx
constructor fails if the external program cannot be started, but it does
not deal with errors that happen after the program has successfully
started running.

``` r
p <- process$new("nonexistant-command-for-sure")
```

``` R
#> Error in `process_initialize()`:
#> ! ! Native call to `processx_exec` failed
#> Caused by error in `chain_call(...)`:
#> ! cannot start processx process 'nonexistant-command-for-sure' (system error 2, No such file or directory) @unix/processx.c:651 (processx_exec)
```

``` r
p2 <- process$new(px, c("sleep", "1", "command-does-not-exist"))
p2$wait()
p2$get_exit_status()
```

``` R
#> [1] 5
```

## Related tools

- The [`ps` package](https://ps.r-lib.org/) can query, list, manipulate
  all system processes (not just subprocesses), and processx uses it
  internally for some of its functionality. You can also convert a
  [`processx::process`](http://processx.r-lib.org/reference/process.md)
  object to a
  [`ps::ps_handle`](https://ps.r-lib.org/reference/ps_handle.html) with
  the `as_ps_handle()` method.

- The [`callr` package](https://callr.r-lib.org/) uses processx to start
  another R process, and run R code in it, in the foreground or
  background.

## Code of Conduct

Please note that the processx project is released with a [Contributor
Code of Conduct](https://processx.r-lib.org/CODE_OF_CONDUCT.html). By
contributing to this project, you agree to abide by its terms.

## License

MIT © Ascent Digital Services, RStudio, Gábor Csárdi

# Package index

## Foreground processes

- [`run()`](http://processx.r-lib.org/reference/run.md) : Run external
  command, and wait until finishes
- [`default_pty_options()`](http://processx.r-lib.org/reference/default_pty_options.md)
  : Default options for pseudo terminals (ptys)

## Background processes

- [`process`](http://processx.r-lib.org/reference/process.md) : External
  process

## Pipelines

- [`pipeline`](http://processx.r-lib.org/reference/pipeline.md)
  **\[experimental\]** : Pipeline of processes connected with pipes

## Polling

- [`poll()`](http://processx.r-lib.org/reference/poll.md) : Poll for
  process I/O or termination
- [`curl_fds()`](http://processx.r-lib.org/reference/curl_fds.md) :
  Create a pollable object from a curl multi handle's file descriptors

## Connections

- [`conn_create_fd()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_file_name()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_create_pipepair()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_create_proc_pipepair()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_read_chars()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`processx_conn_read_chars()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_read_bytes()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`processx_conn_read_bytes()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_read_lines()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`processx_conn_read_lines()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_is_incomplete()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`processx_conn_is_incomplete()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_write()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`processx_conn_write()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_create_file()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_set_stdout()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_set_stderr()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_get_fileno()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`conn_disable_inheritance()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`close(`*`<processx_connection>`*`)`](http://processx.r-lib.org/reference/processx_connections.md)
  [`processx_conn_close()`](http://processx.r-lib.org/reference/processx_connections.md)
  [`is_valid_fd()`](http://processx.r-lib.org/reference/processx_connections.md)
  : Processx connections
- [`conn_create_fifo()`](http://processx.r-lib.org/reference/processx_fifos.md)
  [`conn_connect_fifo()`](http://processx.r-lib.org/reference/processx_fifos.md)
  **\[experimental\]** : Processx FIFOs
- [`conn_create_unix_socket()`](http://processx.r-lib.org/reference/processx_sockets.md)
  [`conn_connect_unix_socket()`](http://processx.r-lib.org/reference/processx_sockets.md)
  [`conn_accept_unix_socket()`](http://processx.r-lib.org/reference/processx_sockets.md)
  [`conn_unix_socket_state()`](http://processx.r-lib.org/reference/processx_sockets.md)
  **\[experimental\]** : Unix domain sockets

## Utility functions

- [`base64_decode()`](http://processx.r-lib.org/reference/base64_decode.md)
  [`base64_encode()`](http://processx.r-lib.org/reference/base64_decode.md)
  : Base64 Encoding and Decoding

# Articles

### All vignettes

- [Process cleanup](http://processx.r-lib.org/articles/cleanup.md):
- [processx internals](http://processx.r-lib.org/articles/internals.md):