# Which Jupyter Kernels Are Supported by OpenSandbox for Multi-Language Code Execution

> OpenSandbox supports Python Java TypeScript Go and Bash kernels for secure multi-language code execution via a unified Jupyter server.

- Repository: [Alibaba/OpenSandbox](https://github.com/alibaba/OpenSandbox)
- Tags: getting-started
- Published: 2026-03-08

---

**OpenSandbox supports five Jupyter kernels: Python (ipykernel), Java (IJava), TypeScript/JavaScript (tslab), Go (gonb), and Bash (bash_kernel), enabling secure, multi-language code execution through a unified Jupyter server backend.**

OpenSandbox is an open-source sandbox environment developed by Alibaba that enables safe execution of arbitrary code across multiple programming languages. At the core of its polyglot execution capability lies a Jupyter server that orchestrates language-specific kernels within containerized sandboxes. Understanding which Jupyter kernels are supported by OpenSandbox helps developers leverage the correct runtime for their specific use cases, from data science with Python to systems scripting with Bash.

## Supported Jupyter Kernels

OpenSandbox ships with a pre-configured set of Jupyter kernels that map programming languages to concrete kernel implementations. These kernels are installed in the `sandboxes/code-interpreter` Docker image and registered during container startup, as documented in [`sandboxes/code-interpreter/README.md`](https://github.com/alibaba/OpenSandbox/blob/main/sandboxes/code-interpreter/README.md).

### Python (ipykernel)

**Python** execution relies on the standard `ipykernel` package. The sandbox supports multiple Python versions, with each version registering its own kernel instance. According to the [`sandboxes/code-interpreter/README.md`](https://github.com/alibaba/OpenSandbox/blob/main/sandboxes/code-interpreter/README.md), the Python kernel provides full access to the scientific Python stack installed in the container.

### Java (IJava)

**Java** code runs through the `IJava` kernel, which compiles and executes Java snippets via the JDK installed in the sandbox. This kernel supports standard Java syntax and library imports, making it suitable for algorithmic challenges and object-oriented code execution.

### TypeScript and JavaScript (tslab)

**TypeScript** and **JavaScript** execution uses the `tslab` kernel, which requires Node.js. This kernel transpiles TypeScript to JavaScript on-the-fly and executes both languages within the same runtime environment, enabling modern web development workflows inside the sandbox.

### Go (gonb)

**Go** programs execute via the `gonb` kernel, which provides a notebook interface for the Go programming language. This kernel compiles Go source files using the Go toolchain installed in the container and streams compilation errors or execution output back to the caller.

### Bash (bash_kernel)

**Bash** scripting is supported through `bash_kernel`, allowing execution of shell commands and scripts. This kernel enables system administration tasks, file manipulation, and command-line utility testing within the isolated sandbox environment.

## Kernel Integration Architecture

The integration of these Jupyter kernels follows a structured pipeline from image build to API exposure. Each component in the alibaba/OpenSandbox repository plays a specific role in kernel lifecycle management.

### Docker Image Build Process

The `sandboxes/code-interpreter/Dockerfile` installs all five kernel implementations during image construction. The build process explicitly installs `ipykernel` for Python, `IJava` for Java, `tslab` for Node.js-based languages, `gonb` for Go, and `bash_kernel` for shell scripting. This ensures that every OpenSandbox container instance contains the complete multi-language runtime environment.

### Jupyter Server Startup

The [`sandboxes/code-interpreter/scripts/code-interpreter.sh`](https://github.com/alibaba/OpenSandbox/blob/main/sandboxes/code-interpreter/scripts/code-interpreter.sh) script launches the Jupyter server during container initialization. This startup script registers all installed kernels with the Jupyter environment and exposes the Jupyter HTTP API on a configurable host, port, and authentication token. The server acts as the central dispatcher for all code execution requests.

### Runtime Kernel Discovery

The Go component [`components/execd/pkg/runtime/jupyter.go`](https://github.com/alibaba/OpenSandbox/blob/main/components/execd/pkg/runtime/jupyter.go) handles kernel selection and session management. When a code execution request arrives, the `searchKernel` function discovers the appropriate kernel name for the requested language (e.g., mapping `"python"` to the `ipykernel` instance). This component creates isolated Jupyter sessions and streams execution results, including stdout, stderr, and return codes, back to the calling process.

### API and SDK Integration

The OpenSandbox REST API defined in [`specs/execd-api.yaml`](https://github.com/alibaba/OpenSandbox/blob/main/specs/execd-api.yaml) (specifically around line 221) accepts a `language` field in execution requests. The Python SDK implementation in [`sdks/sandbox/python/src/opensandbox/api/execd/api/code_interpreting/run_code.py`](https://github.com/alibaba/OpenSandbox/blob/main/sdks/sandbox/python/src/opensandbox/api/execd/api/code_interpreting/run_code.py) wraps this API, allowing developers to specify the target language programmatically. The API forwards requests to the Execd controller, which delegates to the Jupyter runtime for actual execution.

## Multi-Language Execution Examples

Developers interact with these kernels through SDKs or direct HTTP calls, specifying the target language in each request. The following examples demonstrate how to invoke specific kernels using the OpenSandbox Python SDK and raw HTTP requests.

### Running Python Code via SDK

Use the `run_code` method from the `ExecdClient` class to send Python code to the `ipykernel`:

```python
from opensandbox.api.execd import ExecdClient

client = ExecdClient(base_url="http://localhost:8000")
resp = client.run_code(
    language="python",
    code="print('Hello from Python')"
)
print(resp.output)

```

### Running Java Code via SDK

The same `run_code` method accepts Java source code when you specify `language="java"`:

```python
java_code = """
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello from Java");
    }
}
"""
resp = client.run_code(language="java", code=java_code)
print(resp.output)

```

### Direct HTTP API Requests

Send a POST request to the `/execd/v1/code` endpoint with the target language and code payload:

```bash
curl -X POST http://localhost:8000/v1/code \
     -H "Content-Type: application/json" \
     -d '{"language":"typescript","code":"console.log(`Hello from TS`);"}'

```

The server routes this request to the **tslab** kernel, executes the TypeScript snippet, and streams the output back to the client.

### Configuring Runtime Versions

Override default language versions by passing environment variables to the container runtime:

```bash
docker run -it --rm \
  -e PYTHON_VERSION=3.12 \
  -e JAVA_VERSION=21 \
  -e NODE_VERSION=22 \
  -e GO_VERSION=1.25 \
  opensandbox/code-interpreter:latest

```

The container’s entrypoint installs the requested versions and registers the corresponding Jupyter kernels before starting the server.

## Summary

OpenSandbox provides a unified execution environment through these key architectural components:

- **Five supported Jupyter kernels**: Python (`ipykernel`), Java (`IJava`), TypeScript/JavaScript (`tslab`), Go (`gonb`), and Bash (`bash_kernel`).
- **Kernel installation** occurs in `sandboxes/code-interpreter/Dockerfile`, while registration happens via [`sandboxes/code-interpreter/scripts/code-interpreter.sh`](https://github.com/alibaba/OpenSandbox/blob/main/sandboxes/code-interpreter/scripts/code-interpreter.sh).
- **Kernel discovery** is implemented in [`components/execd/pkg/runtime/jupyter.go`](https://github.com/alibaba/OpenSandbox/blob/main/components/execd/pkg/runtime/jupyter.go) through the `searchKernel` function, which maps language identifiers to specific kernels.
- **API integration** uses the `language` field in [`specs/execd-api.yaml`](https://github.com/alibaba/OpenSandbox/blob/main/specs/execd-api.yaml) and the `run_code` method in [`sdks/sandbox/python/src/opensandbox/api/execd/api/code_interpreting/run_code.py`](https://github.com/alibaba/OpenSandbox/blob/main/sdks/sandbox/python/src/opensandbox/api/execd/api/code_interpreting/run_code.py) to route requests.
- **Advanced features** include streaming output, interrupt handling, and multi-session reuse across all supported languages.

## Frequently Asked Questions

### Which programming languages can I execute in OpenSandbox?

OpenSandbox supports Python, Java, TypeScript, JavaScript, Go, and Bash. Each language maps to a specific Jupyter kernel—`ipykernel` for Python, `IJava` for Java, `tslab` for TypeScript/JavaScript, `gonb` for Go, and `bash_kernel` for Bash scripts. This multi-kernel architecture enables polyglot code execution within a single sandbox instance.

### How does OpenSandbox select the correct Jupyter kernel for a request?

The `searchKernel` function in [`components/execd/pkg/runtime/jupyter.go`](https://github.com/alibaba/OpenSandbox/blob/main/components/execd/pkg/runtime/jupyter.go) maps the requested language identifier (e.g., `"python"` or `"java"`) to the corresponding kernel name. This discovery mechanism ensures that code sent to the `/execd/v1/code` endpoint executes in the appropriate runtime environment. The mapping logic handles kernel lifecycle management and session isolation automatically.

### Can I customize the versions of languages available in OpenSandbox?

Yes. When launching the Docker container, set environment variables such as `PYTHON_VERSION`, `JAVA_VERSION`, `NODE_VERSION`, or `GO_VERSION`. The container's entrypoint installs the specified versions and registers them as Jupyter kernels before starting the server. This allows precise control over the runtime environment for each programming language.

### What Jupyter-specific features are available during code execution?

OpenSandbox leverages the full Jupyter protocol, enabling **streaming output** for real-time logs, **interrupt handling** for terminating long-running processes, and **multi-session reuse** for maintaining state across multiple execution requests within the same sandbox instance. These capabilities provide a robust interactive computing environment comparable to native Jupyter notebooks.