Code Execution

View as Markdown

Daytona runs Python, TypeScript, and JavaScript code in sandboxes through language kernels, so untrusted or generated code executes in isolation from your application.

Every run is a code process that executes in a session with a language kernel. The kernel keeps state between runs in the same session, so variables, imports, and functions defined in one run are available in the next. Runs use a shared kernel per language by default; isolated runs and interpreter contexts give code its own kernel. To run shell commands and manage long-running processes, see process execution. To follow a run’s output live, see log streaming.

Use cases

Code execution is used when an application runs Python, TypeScript, or JavaScript that it did not write or does not trust.

AI-generated code: an agent writes code, runs it in the sandbox, and reads the output and errors to correct its next attempt. The code runs isolated from your application.
Data analysis: the kernel keeps data, imports, and functions in memory between runs, so each step builds on the previous one, as in a notebook.
Charts and tables: runs that plot or display data return charts and tables as artifacts with the result. Each artifact is keyed by MIME type, so an application renders it in the right format.
Code interpreters for users: each user or conversation gets its own interpreter context, so state from one does not reach another. A context has its own kernel, working directory, and environment.
Workers that share a context: contexts are addressed by ID. Any worker or process with the sandbox ID and the context ID runs code in the same context.
Live output from long runs: the output of a run streams through log streaming while the code still runs. Exceptions arrive with their name, value, and traceback.
One-off runs: an isolated kernel runs code with no state from earlier runs. The session is deleted after the run, so nothing the code defines reaches other runs.

Run code

Run code in a sandbox. Runs without a context share one kernel per language, so state from one run is available to later runs in that language. The default language is Python.

The result contains the standard output and standard error, rich outputs, the exception if the code raised one, and the exit status of the process.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.v2.create()

response = sandbox.run_code('''
def greet(name):
    return f"Hello, {name}!"

print(greet("Daytona"))
''')
print(response.logs.stdout)

Parameter	Type	Description
`code`	`str`	Sets the code to run. This parameter is required.
`language`	`str`	Sets the language: `python`, `typescript`, or `javascript`. The default is `python`.
`context`	`InterpreterContext`	Runs the code in an interpreter context instead of the shared kernel.
`isolated`	`bool`	Runs the code in a temporary kernel. The default is `False`.
`cwd`	`str`	Sets the working directory for the run.
`env`	`Mapping[str, str]`	Sets environment variables for the shared kernel. The variables apply when the kernel is first created.
`timeout`	`float`	Sets how many seconds the client waits. `0` means no limit. On timeout, the kernel is interrupted and the interrupted result is returned.