# Quickstart

> Run code on a dedicated GPU in minutes, starting from a new account.

Follow this guide to create an account, deploy your first GPU instance, and run code on it.

## Step 1: Create an account

1. Open the [console](https://console.cloud.featherless.ai) and click **Continue with Featherless**.
2. Sign in with your featherless.ai account, or create one. The console needs a verified email address.

Your account comes with a personal **organization**, which owns everything you deploy and the credit that pays for it. Teammates you invite to it later share all of that.

## Step 2: Deploy an instance

An **instance** is a container running on dedicated GPU or CPU compute. You connect to it from your browser or over SSH.

<tabs sync="interface">
<tabs-item label="Deploy via the console">

On the [Instances page](https://console.cloud.featherless.ai/instances), click **Deploy instance**.

<steps level="4">

#### Configure deployment

- **Template**: a container image with its default settings, ready to deploy. The default, **PyTorch (ROCm)**, has Python 3.12, PyTorch and the ROCm GPU libraries installed, with SSH, JupyterLab, and `amd-smi` and `nvtop` for watching the GPU.
- **Set overrides**: replaces the template's image with another, such as your own, for this instance only.

#### Compute

- **GPU model** and **GPU count**: each GPU comes with its own share of CPU and memory, which the **Instance summary** shows.

#### Storage configuration

- **Container disk**: the instance's own disk. It holds the image, everything you install, and your files in `/workspace`. It's erased when the instance stops or restarts, and it's billed only while the instance runs.
- **Network volumes**: persistent storage that lives outside the instance. You mount a volume at a path such as `/workspace`. It keeps its data when instances stop or are deleted, several instances can share it, and it's billed until you delete it.

#### Public ports

HTTP ports in the container that get their own public HTTPS address, for a notebook, an API or a web app. Anyone with the address can reach them.

#### Runtime configuration

- **Start command**: replaces the command the image runs on start.
- **Environment variables**: passed to the container, and visible on the instance's **Details** tab.
- **Secret variables**: encrypted and never shown again. The container reads them as files in `/run/featherless/secrets`, not as environment variables.

</steps>

Click **Review launch** to see the full configuration and hourly rate, then **Launch instance**.

</tabs-item>

<tabs-item label="Deploy via the CLI">

Install the CLI and sign in. `login` opens the console to create an API key, then asks you to paste it.

```bash
curl -fsSL https://console.cloud.featherless.ai/install.sh | sh
featherless-cloud login
```

Deploy an instance from the PyTorch template on one GPU, and check its status:

```bash
featherless-cloud instance create --name quickstart --template featherless/rocm-pytorch --gpu-count 1
featherless-cloud instance get quickstart
```

</tabs-item>
</tabs>

Before the container starts, the instance waits for a GPU and downloads its image. The first start of an image can take a few minutes; later starts are faster. Billing is per second and starts when the container starts, not while you wait.

## Step 3: Run code on your instance

<tabs sync="connect">
<tabs-item label="Browser">

Open the instance's **Terminal** tab. You get a root shell in `/workspace`, with a banner showing the instance's GPUs, hourly cost and storage.

Check that PyTorch can use the GPU:

```bash
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"
```

It prints `True` and the GPU's name. On AMD GPUs, PyTorch's `torch.cuda` API drives the GPU through ROCm, so CUDA code runs unchanged.

The terminal runs in **tmux**, which keeps your shell and programs running after you close the tab, until the instance stops.

</tabs-item>

<tabs-item label="SSH">

1. Add your public key on the [Credentials page](https://console.cloud.featherless.ai/credentials/ssh-keys) with **Add key**. No key yet? Create one with `ssh-keygen -t ed25519`; the public key is `~/.ssh/id_ed25519.pub`. One key works for every instance in your organization.
2. The instance's **Connect** tab shows the SSH command once SSH is ready. You log in as `root`.```bash
ssh <instance-id>@ssh.cloud.featherless.ai
```
3. Run the same check:```bash
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"
```

The same SSH command works for `scp`, `rsync` and remote development in VS Code or Cursor.

</tabs-item>
</tabs>

## Step 4: Clean up

A running instance is billed whether or not you're using it, until you stop or delete it.

<tabs sync="interface">
<tabs-item label="Console">

- **Stop**: keeps the instance's settings, so you can start it again later. Click **Stop** on the instance's page.
- **Delete**: removes the instance and its settings. Click **Delete instance** in the instance's actions menu.

</tabs-item>

<tabs-item label="CLI">

```bash
featherless-cloud instance stop quickstart
featherless-cloud instance delete quickstart
```

</tabs-item>
</tabs>

If your credit runs out, running instances are stopped for you.

## Next steps

<card-group>
<card icon="i-lucide-server" title="Deploy an instance" to="/instances/deploy">

Every setting on the deploy page.

</card>

<card icon="i-lucide-database" title="Network volumes" to="/storage/network-volumes">

Keep datasets, models and checkpoints between runs.

</card>

<card icon="i-lucide-flask-conical" title="Examples" to="/examples">

JupyterLab, model serving and fine-tuning, end to end.

</card>

<card icon="i-lucide-terminal" title="Install the CLI" to="/cli">

Manage everything from your terminal.

</card>
</card-group>
