# Local development

> Developing on a NOVA cloud instance with Visual Studio Code, the Python SDK, and Rerun is a good starting point for building your first robotic programs. Working locally has the advantages that you can use the full power of your own computer, stay in your favorite IDE, keep everything on your company network, and keep working when you're offline.

1. Install the NOVA CLI.
2. Create a project from a template.
3. Run your first robot program in Visual Studio Code.

You do not need Docker or a container registry for this.
That tooling only becomes relevant once you [deploy your app to a NOVA instance](/developer/custom-apps/deploy-app), and you can add it at that point.

## Prerequisites

You have a NOVA cloud instance running including a robot: create the instance in the [NOVA Cloud quickstart](/nova-cloud/quickstart), then add a robot with the [Wandelbots NOVA quickstart](/nova/latest/quickstart).
The local development setup will interact with this instance.

## Install the NOVA CLI

The NOVA CLI is a command-line tool for creating applications and deploying them to Wandelbots NOVA.
It includes additional features that you can explore on [GitHub](https://github.com/wandelbotsgmbh/nova-cli) or after installation by running `nova --help`.

### Step 1: macOS/Linux

Install the Wandelbots NOVA CLI tool using [Homebrew](https://brew.sh/).

```bash
brew install wandelbotsgmbh/wandelbots/nova
```

Enable autocompletion for zsh.

```bash
echo 'source <(nova completion zsh)' >> ~/.zshrc
```

To see all available autocompletion commands for other shell types, run:

```bash
nova completion --help
```

### Step 2: Windows

Find the latest binaries at <https://github.com/wandelbotsgmbh/nova-cli/releases>

Download the binary, rename it to `nova`, and place it inside `C:\Program Files\NovaCLI` (or any other folder of your choice).

Add the folder to your system PATH.

```cmd
setx PATH "%PATH%;C:\Program Files\NovaCLI"
```

Restart your terminal to apply the changes.

### Step 3: Manual installation

1. Download the [Wandelbots NOVA CLI tool](https://github.com/wandelbotsgmbh/nova-cli/releases) and configure it in your local environment.
2. Rename the downloaded file to `nova` and make it executable. Grant the file execution permissions, as the program is not signed. In order to ensure a smooth process, add the Wandelbots NOVA CLI to your terminal's path. The exact process depends on your operating system and terminal.

Video: [/video/develop/nova\_demo.webm#t=0.1](/video/develop/nova_demo.webm#t=0.1)

## Create and run your first project

Now that the CLI is installed, create a project from the Python template and run it.

### Step 1: Create project with Python template

```bash
nova app create myapp
```

The CLI creates a standard Python project that uses `uv` for dependency management and `FastAPI` for the HTTP interface. Default FastAPI routes expose your robotics programs without any extra wiring, and you can extend them whenever you need to customize the API.

> **Info:** Be aware that the standard project template used Typescript in previous releases. The previous command required an additional argument to specify that the python template was to be used.
>
> ```bash
> nova app create "myapp" -g python_app
> ```

> **Warning:** Underscores `_` are not allowed in names due to Kubernetes restrictions. The core project folder will be following the snake\_case naming convention due to Python restrictions.

> **Warning:** Run `uv sync` right after creating the project. It creates the virtual environment and installs all dependencies — the app and the commands below will not run without it.

```bash
uv sync
```

Other helpful `uv` commands:

```bash
# Add a new dependency
uv add some-package
# Download robot models for local Rerun Viewer
uv run download-models
```

The template is optimized for GitHub Copilot and ships with prompts you can reuse:

- `local_setup` checks local prerequisites and tooling.
- `new_program` bootstraps robotics programs that follow the Python SDK patterns.
- `start_server` starts the development server.
- `test_program` runs a selected program.
- `deploy_app` walks you through publishing to NOVA.
- `copilot-instructions.md` documents the project structure and collaboration tips.

Check the official Visual Studio Code [documentation](https://code.visualstudio.com/docs/copilot/customization/prompt-files) to learn more about this feature.

> **Info:** Copilot accelerates the workflow, but it can also introduce incorrect or overly complex code. Knowing Python fundamentals makes it much easier to review Copilot's suggestions and catch issues early.

### Step 2: Update .env file

When working with any project you created with NOVA CLI, you need to make sure the .env file is updated. The following information is needed in the .env file:

- **NOVA\_API**: this is your NOVA HOST. If you have an instance from our cloud, you should put `xxxxx.instance.wandelbots.io`
- **CELL\_NAME**: this is the name of your cell. By default, it named `"cell"`.
- **NOVA\_ACCESS\_TOKEN**: This is the access token you can get from NOVA Cloud, see [Cloud instances](/nova-cloud/cloud-instances). Only set this if you are using an instance from the cloud.
- **LOG\_LEVEL**: The log level of your app. Defaults to `info`.
- **NATS\_BROKER**: Not part of the default `.env.example`. Add it only if you are using NOVA on an IPC or in a virtual machine, set up like this: `ws://IP:80/api/nats`

## Run your first program in Visual Studio Code

You can also run a robot program directly from your editor. The template ships a ready-made launch configuration for Visual Studio Code.

1. Open the project folder in Visual Studio Code.
2. Open `your_nova_app/start_here.py`.
3. Press the play button to run the program.

## Start app

You can also start the app from the command line. This is less commonly needed for regular robot programs, but useful when you want to expose the app's REST API on localhost.

```bash
uv run python -m myapp
```

Then, open the browser at <http://localhost:3000> and see the API.

![NOVA Python application interface](/assets/nova/novax-app.webp)

As you can see you got a couple of APIs out of the box. These APIs are integrated to our system and when you write robotic programs they will automatically be integrated with these APIs.

If you want to extend the project no worries. We only register some routes to your API, you still have the full flexibility to implement new APIs and own the FastAPI object.

That is all you need to develop and test robot programs locally.

## Next steps

Your programs currently run on your machine. To make your app permanently available on the NOVA instance,
continue with [deploying your app](/developer/custom-apps/deploy-app).
