# How to use JetBrains Gateway with a cloud sandbox

Run `runtime sandbox ssh config --install`, then add a Gateway SSH connection to `<id>.runtime`, user `runtime`, using the OpenSSH config.

**On Runtime the IDE backend runs in a microVM of its own, reached through
Runtime's authenticated API, so no SSH port is open to the internet.** You size
the machine to the project, pay for the CPU it uses at $0.025 per active
vCPU-hour plus $0.0075 per reserved GiB-hour of memory, and let it pause when
you stop working ([pricing](/docs/pricing)). There is no plan fee: prepaid
credit starts at $10, and new accounts get 50 free sandbox hours.

## Connect

Once, on your machine:

```bash no-run
npm install --global withruntime
runtime sandbox ssh config --install    # every sandbox becomes <id>.runtime to OpenSSH
```

Then in JetBrains Gateway:

1. Under **SSH**, choose **New Connection**.
2. Host: `<id>.runtime` or `<name>.runtime`. User: `runtime`.
3. Authentication: **Parse config file ~/.ssh/config**, so Gateway uses the
   entry the CLI installed and its `ProxyCommand`.
4. Pick the IDE and the project directory, such as `/workspace/app`.

Gateway downloads the IDE backend into the sandbox and opens the project in
JetBrains Client on your machine, which is the thin window you type in
([JetBrains docs](https://www.jetbrains.com/help/idea/remote-development-a.html),
read 25 September 2026). The backend lands in `~/.cache/JetBrains/RemoteDev/dist`
by default, which in a sandbox is under `/workspace`.

## Size the sandbox for an IDE

An IDE backend indexes the whole project, and JetBrains recommends more CPUs
and memory for larger projects
([prerequisites](https://www.jetbrains.com/help/idea/prerequisites.html), read
25 September 2026). Ask for it at create:

```ts check
import { Sandbox } from "withruntime";

const ide = await Sandbox.getOrCreate("ide", {
  vcpu: 4,
  memoryMiB: 8192,
  diskMiB: 20_480,
  idlePauseSeconds: 1800,
});
console.log(`${ide.info.name}.runtime`);
```

```python check
from withruntime import Sandbox

ide = Sandbox.get_or_create("ide", vcpu=4, memory_mib=8192, disk_mib=20_480,
                            idle_pause_seconds=1800)
print(f"{ide.info['name']}.runtime")
```

```bash no-run
runtime sandbox create --name ide --get-or-create --vcpu 4 --memory 8192 --disk 20480 --idle-pause 1800
```

| Resource | What it costs                                    | Note                                                       |
| -------- | ------------------------------------------------ | ---------------------------------------------------------- |
| CPU      | $0.025 per active vCPU-hour, as used             | Idle cores between builds cost the 50-millicore floor only |
| Memory   | $0.0075 per reserved GiB-hour                    | 8 GiB is $0.06 an hour while running                       |
| Disk     | Chosen with `--disk`                             | The IDE backend and its caches live on it                  |
| Paused   | $0.08 per decimal GB per 30-day month of storage | No compute charge; files, memory and processes are kept    |

Indexing is the busy part; once it is done, a backend that waits for you uses
little CPU, and CPU is billed on what is measured.

## Keep the project warm

A named sandbox with an idle pause is the same workspace every morning, its
index still on disk. To build that workspace faster the first time, start from
a [custom image](/docs/images) that already has your JDK, Python or Node
toolchain; `sudo apt-get install -y openjdk-21-jdk` works too, once per
sandbox.

## Mistakes and how Runtime handles them

- **Choosing a password or a key file in Gateway.** The installed entry's
  `ProxyCommand` is what reaches the sandbox, so choose the option that parses
  `~/.ssh/config`.
- **The IDE drops after a long break.** An open connection does not keep a
  sandbox running; when its lease pauses or stops it, the session ends. Extend
  the lease, or make a paid sandbox `--persistent` for all-day work.
- **Sessions past a day.** Each SSH connection lasts at most 24 hours; open it
  again to go on.
- **Several IDEs and forwards at once.** An organization has at most 16 SSH
  logins and port forwards open together.
- **Running out of disk.** The default 4 GiB disk had about 2.5 GiB free on
  24 September 2026, too little for an IDE backend and a large project; ask for
  more at create.

## Gateway, VS Code or a shell?

Gateway suits Java, Kotlin and other projects where a JetBrains IDE's indexing
and refactoring are the reason you use it. [VS Code Remote-SSH](/how-to/use-vs-code-remote-ssh)
keeps the editor on your machine and runs its server in the sandbox. For quick fixes, [SSH in](/how-to/ssh-into-a-sandbox)
from a terminal. All of them use the same `<id>.runtime` host.

## Related

- [SSH and editors](/docs/editors).
- [Java in a sandbox](/languages/java) and [Kotlin](/languages/kotlin).
- [Per-user dev environments](/use-cases/per-user-dev-environments).

## Sources

- JetBrains, "Connect and work with JetBrains Gateway",
  https://www.jetbrains.com/help/idea/remote-development-a.html, read
  25 September 2026.
- JetBrains, "Prerequisites", https://www.jetbrains.com/help/idea/prerequisites.html,
  read 25 September 2026.

Facts on this page were checked on 25 September 2026.