# How to Execute Shell Commands in Different Languages Using Open Interpreter's Terminal Tool

> Learn how to execute shell commands in any language with Open Interpreters Terminal tool. This guide covers preprocessing, execution, and output streaming for seamless command execution.

- Repository: [Open Interpreter/open-interpreter](https://github.com/openinterpreter/open-interpreter)
- Tags: how-to-guide
- Published: 2026-03-05

---

**Open Interpreter's Terminal tool dispatches shell commands through language-specific handlers that preprocess code, inject execution markers, and stream output from subprocesses while enforcing user approval prompts.**

The `openinterpreter/open-interpreter` repository provides a unified interface for executing code across multiple languages. When you need to execute shell commands in different languages using the terminal tool, the system routes your request through a specialized dispatch mechanism that handles everything from syntax preprocessing to safety confirmations.

## Understanding the Terminal Tool Architecture

The Terminal component acts as an abstraction layer over the underlying operating system shell. Located in [`interpreter/core/computer/terminal/terminal.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/terminal.py), the `Terminal` class discovers language-specific handlers and manages the execution flow.

When you invoke a command, `Terminal.run(language, code, ...)` looks up the appropriate class via `Terminal.get_language()` [【^1†L73-L80】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/terminal.py#L73-L80). This dispatch system supports multiple languages including shell variants (bash, zsh), Python, Ruby, and PowerShell.

## Executing Shell Commands via the Terminal Interface

### Direct Shell Execution

The simplest way to execute shell commands is through the `interpreter.computer.run()` method, specifying `"shell"` as the language parameter:

```python
output = interpreter.computer.run(
    language="shell",                # aliases: "bash", "zsh", "sh"

    code="ls -la /tmp",
    stream=False,                    # collect full output

    display=True                     # print to console

)
print(output)  # [{'type': 'console', 'format': 'output', 'content': '...'}]

```

### Language Dispatch Mechanism

Behind the scenes, the Terminal instantiates the `Shell` class from [`interpreter/core/computer/terminal/languages/shell.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/languages/shell.py) [【^2†L8-L22】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/languages/shell.py#L8-L22). This class inherits from `SubprocessLanguage`, which spawns `/bin/bash` on Unix systems or `cmd.exe` on Windows.

The `Terminal._streaming_run()` method creates an instance of the language class and yields each chunk from its `run()` generator [【^1†L56-L66】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/terminal.py#L56-L66).

## Shell Language Implementation and Execution Flow

### Preprocessing and Active Line Markers

Before execution, the `Shell` class preprocesses code to inject execution tracking markers. The `preprocess_code()` method adds *active-line* markers and an end-of-execution token to help the LLM monitor progress [【^2†L24-L38】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/languages/shell.py#L24-L38).

These markers enable real-time feedback during streaming execution, allowing the system to identify which line is currently running.

### Subprocess Execution

The actual command execution occurs through the `SubprocessLanguage` base class, which:

1. Spawns a persistent subprocess with `/bin/bash` or `cmd.exe`
2. Streams stdout and stderr in real-time
3. Handles process lifecycle management

This architecture ensures that shell commands execute in a controlled environment with proper output capture.

## Alternative: Using the Anthropic Bash Tool

For LLM-driven workflows, Open Interpreter provides the `BashTool` in [`interpreter/computer_use/tools/bash.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/computer_use/tools/bash.py). This tool creates a persistent bash session (`_BashSession`) and executes commands after user approval [【^3†L10-L18】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/computer_use/tools/bash.py#L10-L18).

When the LLM invokes the bash tool, the system prompts for explicit confirmation:

```python

# LLM generates a tool call like:

# {"name": "bash", "arguments": {"command": "git status"}}

# Open Interpreter translates this to:

await interpreter.llm.call_tool(
    tool_name="bash",
    command="git status"
)

# The BashTool prompts:

# Do you want to execute the following command?

# git status

# Enter 'yes' to proceed, anything else to cancel:

```

The `BashTool.run()` method handles the confirmation prompt and session management [【^3†L49-L60】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/computer_use/tools/bash.py#L49-L60).

## Safety Mechanisms and User Approval

Open Interpreter implements multiple safety layers when executing shell commands:

**Confirmation Prompts**: Both the Terminal interface and BashTool require explicit user approval before executing arbitrary shell commands. The BashTool prints the full command and waits for `'yes'` input.

**Package Installation Handling**: The Terminal intercepts `apt install` calls and attempts sudo-less installation first, falling back to a password prompt if needed [【^1†L83-L89】](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/terminal.py#L83-L89).

**Subprocess Isolation**: Commands execute in isolated subprocesses rather than the main process, preventing accidental corruption of the interpreter state.

## Summary

- Open Interpreter's Terminal tool dispatches shell commands through language-specific handlers located in `interpreter/core/computer/terminal/languages/`.
- Use `interpreter.computer.run("shell", "command")` for direct execution, or invoke the `BashTool` for LLM-driven workflows requiring explicit approval.
- The `Shell` class preprocesses code with active-line markers and streams output through a persistent subprocess.
- Safety mechanisms include user confirmation prompts, sudo-less package installation attempts, and subprocess isolation.

## Frequently Asked Questions

### How do I run a shell command from Python code in Open Interpreter?

You can use Python's `subprocess` module within a Python code block. The interpreter executes the Python code, which then spawns the shell subprocess:

```python
interpreter.computer.run(
    language="python",
    code="""
import subprocess
result = subprocess.run(['ls', '-la'], capture_output=True, text=True)
print(result.stdout)
"""
)

```

### What is the difference between the Terminal tool and the BashTool?

The **Terminal tool** (`interpreter.computer.run`) is the primary interface for executing code in various languages including shell. It handles language dispatch, preprocessing, and streaming output. The **BashTool** ([`interpreter/computer_use/tools/bash.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/computer_use/tools/bash.py)) is specifically designed for Anthropic-style LLM tool calls, providing a persistent bash session with explicit user confirmation prompts before execution.

### How does Open Interpreter handle dangerous shell commands?

Open Interpreter implements multiple safety layers. The Terminal intercepts potentially destructive operations like `apt install` and attempts sudo-less installation first. The BashTool requires explicit user approval by printing the command and waiting for a `'yes'` response. Additionally, all shell commands execute in isolated subprocesses rather than the main interpreter process to prevent state corruption.

### Can I use shell aliases like "bash" or "zsh" instead of "shell"?

Yes, the Terminal's language dispatch system recognizes multiple aliases for the shell language. When you specify `"bash"`, `"zsh"`, `"sh"`, or `"shell"` as the language parameter, `Terminal.get_language()` resolves these aliases to the `Shell` class in [`interpreter/core/computer/terminal/languages/shell.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/computer/terminal/languages/shell.py).