> For the complete documentation index, see [llms.txt](https://lune.gitbook.io/lune/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://lune.gitbook.io/lune/api-reference/process.md).

# process

Built-in functions for the current process & child processes

### Example usage

```lua
local process = require("@lune/process")

-- Getting the arguments passed to the Lune script
for index, arg in process.args do
    print("Process argument #" .. tostring(index) .. ": " .. arg)
end

-- Getting the currently available environment variables
local PORT: string? = process.env.PORT
local HOME: string? = process.env.HOME
for name, value in process.env do
    print("Environment variable " .. name .. " is set to " .. value)
end

-- Getting the current os and processor architecture
print("Running " .. process.os .. " on " .. process.arch .. "!")

-- Spawning a child process
local result = process.spawn("program", {
    "cli argument",
    "other cli argument"
})
if result.ok then
    print(result.stdout)
else
    print(result.stderr)
end
```

***

## Properties

### arch

The architecture of the processor currently being used.

Possible values:

* `"x86_64"`
* `"aarch64"`

### cwd

The current working directory in which the Lune script is running.

### os

The current operating system being used.

Possible values:

* `"linux"`
* `"macos"`
* `"windows"`

***

## Functions

### exit

```lua
function Process.exit(code: number?)
```

Exits the currently running script as soon as possible with the given exit code.

Exit code 0 is treated as a successful exit, any other value is treated as an error.

Setting the exit code using this function will override any otherwise automatic exit code.

### spawn

```lua
function Process.spawn(program: string, params: { string }?, options: SpawnOptions?)
```

Spawns a child process that will run the program `program`, and returns a dictionary that describes the final status and ouput of the child process.

The second argument, `params`, can be passed as a list of string parameters to give to the program.

The third argument, `options`, can be passed as a dictionary of options to give to the child process. Refer to the documentation for `SpawnOptions` for specific option keys and their values.

***

## Types

### Arch

```lua
type Arch = "x86_64" | "aarch64"
```

### OS

```lua
type OS = "linux" | "macos" | "windows"
```

### SpawnOptions

```lua
type SpawnOptions = {
	cwd: string?,
	env: { [string]: string }?,
	shell: (boolean | string)?,
	stdio: SpawnOptionsStdio?,
}
```

A dictionary of options for `process.spawn`, with the following available values:

* `cwd` - The current working directory for the process
* `env` - Extra environment variables to give to the process
* `shell` - Whether to run in a shell or not - set to `true` to run using the default shell, or a string to run using a specific shell
* `stdio` - How to treat output and error streams from the child process - set to "inherit" to pass output and error streams to the current process

### SpawnOptionsStdio

```lua
type SpawnOptionsStdio = "inherit" | "default"
```

### SpawnResult

```lua
type SpawnResult = {
	ok: boolean,
	code: number,
	stdout: string,
	stderr: string,
}
```

Result type for child processes in `process.spawn`.

This is a dictionary containing the following values:

* `ok` - If the child process exited successfully or not, meaning the exit code was zero or not set
* `code` - The exit code set by the child process, or 0 if one was not set
* `stdout` - The full contents written to stdout by the child process, or an empty string if nothing was written
* `stderr` - The full contents written to stderr by the child process, or an empty string if nothing was written


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://lune.gitbook.io/lune/api-reference/process.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.