ShIO-bash-26.1

Shell input-output (ShIO) Bash dataset produced by ShIOEnv, a Gymnasium-compatible Bash environment designed to collect execution-annotated command interactions in a Linux system.

Dataset summary

The dataset consists of command-line inputs paired with their execution artifacts, including observable outputs and a structured representation of environment state changes. Samples are produced by executing synthesized Bash inputs inside a snapshot-reverted Ubuntu 24.04 microVM, yielding system-grounded behavior for each input.

The dataset contains 2.1M unique samples spanning 86 Linux utilities executed on Ubuntu 24.04.

Motivation and intended use

The dataset targets learning problems that require predicting system-specific command behavior without executing commands at inference time. Typical uses include:

• Execution-free CLI simulation that predicts stdout and stderr, exit status, and environment effects.
• Training or evaluating sequence-to-sequence models that map input -> {output, context_patch}.
• Studying argument sensitivity.

The dataset is not intended as a general corpus of human-authored shell usage. Inputs are primarily synthesized rather than collected from user sessions.

Dataset composition

Sampling sources

The dataset is organized by synthesis regime, as described in the paper:

• GCS: grammar-constrained synthesis using command-specific context-free grammars.
• UCS: unconstrained synthesis that expands from a universal production space.
• Adapted NL2CMD: a bootstrapped subset derived from NL2CMD, modified to use system-specific artifacts present in the target environment.
• eval: human-annotated samples sourced from user logs used to benchmark modeling performance.

These appear as directory-level groupings (data/GCS/, data/UCS/, data/NL2CMD/, data/eval) with newline-delimited JSON shards.

Execution environment

All samples are grounded in a fixed Ubuntu 24.04 environment executed in a Firecracker microVM, reverted to a snapshot before each execution to ensure consistent context for contrasts and patch computation.

The environment includes a curated filesystem containing directories and artifacts intended to support diverse command behaviors.

Unit of observation

Each record corresponds to one executed "session" input string. A session may be:

• A single command invocation.
• A composite input using operators such as pipes, redirections, and logical connectors, depending on the grammar and synthesis regime.

Data fields

Each record is a JSON object. The paper specifies seven fields (names may vary slightly across releases). In the provided .ndjson shards, the observed schema is:

Field	Type	Description
session_id	integer	Identifier for the sample.
input	string	Executed shell input string for the session. Some sessions may include an initial working-directory prefix (for example cd <cwd>;) to encode starting context.
input_args	list[string]	Tokenized argument list used to represent the input as removable arguments. The representation may include the marker <ns> to indicate "no-space" boundaries used to reconstruct compact flags or concatenated tokens.
exit_code	integer	Exit status returned by the last executed command in the session.
output	string	Observed output from execution, comprising stdout and stderr content (as recorded by the environment).
context_patch	string	JSON-encoded list of compact RFC 6902-style patch operations representing latent environment changes.
redundancy_score	float	A length-weighted ablation-based score in [0, 1] corresponding to irreducibility signal (higher values indicate more behaviorally informative arguments under ablation).

Context patch encoding

context_patch encodes a list of operations over an abstract environment context object. The paper uses a compact operation alphabet:

• ["a", "/path", value] add
• ["=", "/path", value] replace
• ["r", "/path"] remove
• ["m", "/from", "/to"] move

Patch paths are JSON Pointer-like strings into a system feature map containing elements such as filesystem metadata, working directory, environment variables, shell options, resource limits, and firewall rules.

Data format and storage

• Files are stored as NDJSON (one JSON object per line).
• Each file contains 1K entries in JSON long format.
• Files are organized by synthesis source directory.

Sample record:

{
  "session_id": 1853,
  "input": "mv -S Z -v .bash_logout newfile",
  "input_args": ["mv", "-S Z", "-v<ns>", ".bash_logout", "newfile"],
  "output": "renamed '.bash_logout' -> 'newfile'",
  "exit_code": 0,
  "redundancy_score": 0.896551724137931,
  "context_patch": "[[\"m\",\"/fs/.bash_logout\",\"/fs/newfile\"]]",
},
{
  "session_id": 1954,
  "input": "ls -w 8 --show-control-chars -a update_notes.txt config_settings.json",
  "input_args": ["ls", "-w 8", "--show-control-chars", "-a<ns>", "update_notes.txt config_settings.json"],
  "output": "config_settings.json\nupdate_notes.txt",
  "exit_code": 0,
  "redundancy_score": 0.4482758620689655,
  "context_patch": "[]",
}

Data generation and labeling process

• Inputs are synthesized using context-free grammars over command syntaxes for a fixed set of utilities.

• Each synthesized session is executed in a snapshot-reverted microVM to collect:

  • stdout and stderr output,
  • exit status,
  • a before-after snapshot of the abstract environment context, summarized as a patch.

• Each sample includes an irreducibility score computed by comparing the full input’s execution artifacts against those produced by ablations that remove subsets of arguments, using a budgeted Monte Carlo estimator to avoid exhaustive enumeration.

Known characteristics and potential biases

• System specificity: behaviors reflect those of a specific Ubuntu 24.04 filesystem. Models trained using this dataset should be expected to represent these same behaviors. Representing other systems can be done through changing ShIOEnv's execution backend.
• Synthesis-induced distribution shift: grammar-constrained and unconstrained synthesis shape the command and argument distribution independent of usage trends. NL2CMD inherits distribution characteristics from its source.
• Non-determinism and normalization: Commands may produce variable outputs when executed. The irreducibility computation uses a noise-tolerant similarity threshold to suppress spurious differences, which can bias scores for highly variable commands.

Limitations

• Coverage is limited to the utilities with defined grammars and to the maximum argument horizons used during synthesis.
• Changes to the system state are represented by a patch over a mined system feature map rather than a full system snapshot. As a result, the reported changes to the system a command induces should be treated as non-exhaustive.
• Records may contain near-duplicates arising from syntactic variants or argument redundancy, though the irreducibility signal is intended to quantify this redundancy.
• There may be repeated inputs as samples were collected across multiple hosts.

Ethical and safety considerations

The dataset contains command strings and system outputs that can include security-relevant tooling and patterns. While the dataset is intended to support safer execution-free simulation and honeypot design, it may also lower barriers to generating plausible CLI interactions. Deployment should consider misuse risk, especially in contexts involving adversarial emulation.

The dataset is synthesized and system-grounded rather than collected from users, so it is not expected to contain personal user data. However, outputs can include paths, filenames, and environment metadata that reflect the constructed system context, host information, or behavior-capturing inputs.

Citation

If this dataset is used in support of research, please use the following citation:

@misc{ragsdale2026shioenv,
      title={ShIOEnv: A Command Evaluation Environment for Grammar-Constrained Synthesis and Execution Behavior Modeling}, 
      author={Jarrod Ragsdale and Rajendra Boppana},
      year={2026},
      eprint={2505.18374},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2505.18374}, 
}