`val argv : string array`

The command line arguments given to the process. The first element is the command name used to invoke the program. The following elements are the command-line arguments given to the program.

`val executable_name : string`

The name of the file containing the executable currently running.

`val file_exists : string -> bool`

Test if a file with the given name exists.

`val is_directory : string -> bool`

Returns `true` if the given name refers to a directory, `false` if it refers to another kind of file.

- raises `Sys_error`

  if no file exists with the given name.

- since 3.10.0

`val remove : string -> unit`

Remove the given file name from the file system.

`val rename : string -> string -> unit`

Rename a file. The first argument is the old name and the second is the new name. If there is already another file under the new name, `rename` may replace it, or raise an exception, depending on your operating system.

`val getenv : string -> string`

Return the value associated to a variable in the process environment.

- raises `Not_found`

  if the variable is unbound.

`val getenv_opt : string -> string option`

Return the value associated to a variable in the process environment or `None` if the variable is unbound.

- since 4.05

`val command : string -> int`

Execute the given shell command and return its exit code.

`val time : unit -> float`

Return the processor time, in seconds, used by the program since the beginning of execution.

`val chdir : string -> unit`

Change the current working directory of the process.

`val getcwd : unit -> string`

Return the current working directory of the process.

`val readdir : string -> string array`

Return the names of all files present in the given directory. Names denoting the current directory and the parent directory (`"."` and `".."` in Unix) are not returned. Each string in the result is a file name rather than a complete path. There is no guarantee that the name strings in the resulting array will appear in any specific order; they are not, in particular, guaranteed to appear in alphabetical order.

`val interactive : bool Stdlib.ref`

This reference is initially set to `false` in standalone programs and to `true` if the code is being executed under the interactive toplevel system `ocaml`.

`val os_type : string`

Operating system currently executing the OCaml program. One of

- `"Unix"` (for all Unix versions, including Linux and Mac OS X),
- `"Win32"` (for MS-Windows, OCaml compiled with MSVC++ or Mingw),
- `"Cygwin"` (for MS-Windows, OCaml compiled with Cygwin).

`type backend_type = Stdlib.Sys.backend_type =`

1. `| Native`
2. `| Bytecode`
3. `| Other of string`

Currently, the official distribution only supports `Native` and `Bytecode`, but it can be other backends with alternative compilers, for example, javascript.

- since 2.5.3 and 4.04

`val backend_type : backend_type`

Backend type currently executing the OCaml program.

- since 2.5.3 and 4.04

`val unix : bool`

True if `Sys.os_type = "Unix"`.

- since 4.01.0

`val win32 : bool`

True if `Sys.os_type = "Win32"`.

- since 4.01.0

`val cygwin : bool`

True if `Sys.os_type = "Cygwin"`.

- since 4.01.0

`val word_size : int`

Size of one word on the machine currently executing the OCaml program, in bits: 32 or 64.

`val int_size : int`

Size of an int. It is 31 bits (resp. 63 bits) when using the OCaml compiler on a 32 bits (resp. 64 bits) platform. It may differ for other compilers, e.g. it is 32 bits when compiling to JavaScript.

- since 2.5.0 and OCaml 4.03.0

`val big_endian : bool`

Whether the machine currently executing the OCaml program is big-endian.

- since 4.00.0

`val max_string_length : int`

Maximum length of a string.

`val max_array_length : int`

Maximum length of a normal array. The maximum length of a float array is `max_array_length/2` on 32-bit machines and `max_array_length` on 64-bit machines.

`val max_floatarray_length : int`

Maximum length of a floatarray. This is also the maximum length of a `float array` when OCaml is configured with `--enable-flat-float-array`.

`val runtime_variant : unit -> string`

Return the name of the runtime variant the program is running on. This is normally the argument given to `-runtime-variant` at compile time, but for byte-code it can be changed after compilation.

- since 2.5.0 and OCaml 4.03.0

`val runtime_parameters : unit -> string`

Return the value of the runtime parameters, in the same format as the contents of the `OCAMLRUNPARAM` environment variable.

- since 2.5.0 and OCaml 4.03.0

`val poll_actions : unit -> unit`

Run any pending runtime actions, such as minor collections, major GC slices, signal handlers, finalizers, or memprof callbacks.

- since 3.9.0 and OCaml 5.3

`val is_regular_file : string -> bool`

## Signal handling

`type signal_behavior = Stdlib.Sys.signal_behavior =`

1. `| Signal_default`
2. `| Signal_ignore`
3. `| Signal_handle of int -> unit`
   (*

   What to do when receiving a signal:

   - `Signal_default`: take the default behavior (usually: abort the program)
   - `Signal_ignore`: ignore the signal
   - `Signal_handle f`: call function `f`, giving it the signal number as argument.
   *)

`val signal : int -> signal_behavior -> signal_behavior`

Set the behavior of the system on receipt of a given signal. The first argument is the signal number. Return the behavior previously associated with the signal.

- raises `Invalid_argument`

  If the signal number is invalid (or not available on your system).

`val set_signal : int -> signal_behavior -> unit`

Same as `Sys.signal` but return value is ignored.

### Signal numbers for the standard POSIX signals.

`val sigabrt : int`

Abnormal termination

`val sigalrm : int`

Timeout

`val sigfpe : int`

Arithmetic exception

`val sighup : int`

Hangup on controlling terminal

`val sigill : int`

Invalid hardware instruction

`val sigint : int`

Interactive interrupt (ctrl-C)

`val sigkill : int`

Termination (cannot be ignored)

`val sigpipe : int`

Broken pipe

`val sigquit : int`

Interactive termination

`val sigsegv : int`

Invalid memory reference

`val sigterm : int`

Termination

`val sigusr1 : int`

Application-defined signal 1

`val sigusr2 : int`

Application-defined signal 2

`val sigchld : int`

Child process terminated

`val sigcont : int`

Continue

`val sigstop : int`

Stop

`val sigtstp : int`

Interactive stop

`val sigttin : int`

Terminal read from background process

`val sigttou : int`

Terminal write from background process

`val sigvtalrm : int`

Timeout in virtual time

`val sigprof : int`

Profiling interrupt

`val sigbus : int`

Bus error

- since 2.5.0

`val sigpoll : int`

Pollable event

- since 2.5.0

`val sigsys : int`

Bad argument to routine

- since 2.5.0

`val sigtrap : int`

Trace/breakpoint trap

- since 2.5.0

`val sigurg : int`

Urgent condition on socket

- since 2.5.0

`val sigxcpu : int`

Timeout in cpu time

- since 2.5.0

`val sigxfsz : int`

File size limit exceeded

- since 2.5.0

`exception Break`

Exception raised on interactive interrupt if `Sys.catch_break` is on.

`val catch_break : bool -> unit`

`catch_break` governs whether interactive interrupt (ctrl-C) terminates the program or raises `Break`. Call `catch_break true` to enable raising `Break`, and `catch_break false` to let the system terminate the program on user interrupt.

`val ocaml_version : string`

`ocaml_version` is the version of OCaml. It is a string of the form `"major.minor[.patchlevel][+additional-info]"`, where `major`, `minor`, and `patchlevel` are integers, and `additional-info` is an arbitrary string. The `[.patchlevel]` and `[+additional-info]` parts may be absent.

`val development_version : bool`

`true` if this is a development version, `false` otherwise.

- since 4.14.0

`type extra_prefix = Stdlib.Sys.extra_prefix =`

1. `| Plus`
2. `| Tilde`

`type extra_info = Stdlib.Sys.extra_info`
`type ocaml_release_info = Stdlib.Sys.ocaml_release_info = {`

1. `major : int;`
2. `minor : int;`
3. `patchlevel : int;`
4. `extra : extra_info option;`

`}`
`val ocaml_release : ocaml_release_info`
`val files_of : string -> string BatEnum.t`

As `readdir` but the results are presented as an enumeration of names.

`val enable_runtime_warnings : bool -> unit`

Control whether the OCaml runtime system can emit warnings on stderr. Currently, the only supported warning is triggered when a channel created by `open_*` functions is finalized without being closed. Runtime warnings are enabled by default.

- since 2.5.0 and OCaml 4.03

`val runtime_warnings_enabled : unit -> bool`

Return whether runtime warnings are currently enabled.

- since 2.5.0 and OCaml 4.03

## Optimization

`val opaque_identity : 'a -> 'a`

For the purposes of optimization, `opaque_identity` behaves like an unknown (and thus possibly side-effecting) function.

At runtime, `opaque_identity` disappears altogether.

A typical use of this function is to prevent pure computations from being optimized away in benchmarking loops. For example:

      for _round = 1 to 100_000 do
        ignore (Sys.opaque_identity (my_pure_computation ()))
      done

The compiler primitive was added to OCaml 4.03, but we emulate it under 4.02 using the -opaque compilation flag. There is no easy way for Batteries to emulate it correctly under older OCaml versions.

- since 2.5.0 and OCaml 4.02

`module Immediate64 = Stdlib.Sys.Immediate64`
`val mkdir : string -> int -> unit`

Create a directory with the given permissions.

- since 3.3.0 and 4.12.0

`val rmdir : string -> unit`

Remove an empty directory.

- since 3.3.0 and 4.12.0

`val io_buffer_size : int`
`type signal = int`
`val sigio : signal`
`val sigwinch : signal`
`val signal_to_string : signal -> string`
`val signal_of_int : int -> signal`
`val signal_to_int : signal -> int`