> ## Documentation Index
> Fetch the complete documentation index at: https://docs.risingwave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Standalone mode

> Learn about RisingWave's standalone mode, a simplified deployment option that runs an entire cluster as a single process. Discover how to configure it, use its embedded local storage, and set up monitoring with Grafana and Prometheus for a minimal, easy-to-manage setup.

RisingWave standalone mode is a simplified deployment mode for RisingWave. It is designed to be minimal, easy to install, and configure.

Unlike other deployment modes, for instance [Docker Compose](/deploy/risingwave-docker-compose) or [Kubernetes](/deploy/risingwave-kubernetes), RisingWave standalone mode starts the cluster as a single process. This means that components including `serving node`, `streaming node`, `meta node`, and `compactor node` are all embedded in this process.

RisingWave by default uses object storage to persist data. In the standalone mode, we use the embedded `LocalFs` Object Store, eliminating the need for an external service like `minio` or `s3`; for meta store, we will use the embedded `SQLite` database, eliminating the need for an external service like `etcd`.

By default, the RisingWave standalone mode will store its data in `~/.risingwave`, which includes both `Metadata` and `State Data`.

For a batteries-included setup, with `monitoring` tools and external services like `kafka` fully included, you can use [Docker Compose](/deploy/risingwave-docker-compose) instead. If you would like to set up these external services manually, you may check out RisingWave's [Docker Compose](https://github.com/risingwavelabs/risingwave/blob/main/docker/docker-compose.yml), and run these services using the same configurations.

## Install RisingWave

You can install RisingWave standalone mode using one of the following methods:

### Script installation

Open a terminal and run the following `curl` command:

```bash theme={null}
curl -L https://risingwave.com/sh | sh
```

### Docker

Ensure [Docker Desktop](https://docs.docker.com/get-docker/) is installed and running in your environment.

```bash theme={null}
docker run -it --pull=always -p 4566:4566 -p 5691:5691 risingwavelabs/risingwave:latest single_node
```

Ensure your hardware supports the required SIMD extensions (AVX2 for x86\_64, NEON for ARM64). See [SIMD requirements for Docker images](/deploy/hardware-requirements#supported-architectures) for details.

### Homebrew

Ensure [Homebrew](https://brew.sh/) is installed, and run the following commands:

```bash theme={null}
brew tap risingwavelabs/risingwave
brew install risingwave
```

## Start RisingWave

After installation, start RisingWave using one of the following methods:

**For Script and Homebrew installations:**

```bash theme={null}
risingwave
```

**For Docker:**

The Docker command above starts RisingWave automatically. No additional command is needed.

## Configure RisingWave standalone mode

The instance of RisingWave standalone mode can run without any configuration. However, there are some options available to customize the instance.

The main options which new users may require would be the state store directory (`--state-store-directory`) and in-memory mode (`--in-memory`).

`--state-store-directory` specifies the new directory where the cluster's `Metadata` and `State Data` will reside. The default is to store it in the `~/.risingwave` folder.

```bash theme={null}
# Reconfigure RisingWave to be stored under 'projects' folder instead.
risingwave --state-store-directory ~/projects/risingwave
```

`--in-memory` will run an in-memory instance of RisingWave, both `Metadata` and `State Data` will not be persisted.

```bash theme={null}
risingwave --in-memory
```

You can view other options with:

```bash theme={null}
risingwave single --help
```

## Monitor RisingWave standalone mode with Grafana and Prometheus

To monitor your standalone cluster, you may wish to integrate metrics monitoring with Grafana and Prometheus.

First install [Grafana](https://grafana.com/docs/grafana/latest/setup-grafana/installation/) and [Prometheus](https://prometheus.io/docs/prometheus/latest/installation/).

Next, clone the [RisingWave](https://github.com/risingwavelabs/risingwave) repository, it contains various configuration files.

Start the RisingWave standalone cluster.

Make sure you're in the `RisingWave` directory.

Start your prometheus instance:

```bash theme={null}
prometheus --config.file=./standalone/prometheus.yml --web.listen-address=0.0.0.0:9500
```

Then start the Grafana instance:

```bash theme={null}
grafana server --config ./standalone/grafana.ini
```

Next, add the Prometheus Data Source on the Grafana Dashboard: [http://localhost:3001/connections/datasources/prometheus](http://localhost:3001/connections/datasources/prometheus).

```bash theme={null}
name: risedev-prometheus
Prometheus Server URL: http://localhost:9500
```

Finally, import the dashboards at [http://localhost:3001/dashboard/import](http://localhost:3001/dashboard/import). The file paths are `grafana/risingwave-dev-dashboard.json` (recommended) and `grafana/risingwave-user-dashboard.json` (also available).

With that you can now monitor your standalone cluster with Grafana and Prometheus.