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

# Install QuanuX on Linux or macOS

> Three ways to install QuanuX: the official Conda channel, pip with a virtual environment, or a full source build. Covers all prerequisites and platform notes.

QuanuX supports three installation paths depending on your workflow. Conda is the recommended approach for most users — it handles Python dependencies, manages your environment alongside data science tools, and installs from the official QuanuX channel with no manual dependency resolution. If you're already working in a pip-based environment or want to contribute to the codebase, the venv and source build paths are fully supported.

## Prerequisites

Before installing, confirm you have the following available on your system:

| Dependency   | Version | Required for                        |
| ------------ | ------- | ----------------------------------- |
| Python       | 3.10+   | Server and strategy runtime         |
| Node.js      | v20+    | Cockpit client                      |
| pnpm         | Latest  | Cockpit client build and dev        |
| Rust & Cargo | Stable  | Tauri desktop app (dev builds only) |

<Note>
  Linux is the primary target platform for execution nodes. The server and CLI run on Linux and macOS. The Tauri desktop cockpit runs on Linux, macOS, and Windows. If you're setting up a production execution node, use a Linux server.
</Note>

***

## Option 1: Conda (recommended)

QuanuX is the first quantitative trading platform to offer an official Conda channel. Installing through Conda places QuanuX in a managed environment alongside your Python data science stack — pandas, polars, numpy, DuckDB, and more — and lets you launch QuanuX directly from Anaconda Navigator.

<Steps>
  <Step title="Add the QuanuX and conda-forge channels">
    ```bash theme={null}
    conda config --add channels conda-forge
    conda config --add channels QuanuX
    ```
  </Step>

  <Step title="Install QuanuX">
    ```bash theme={null}
    conda install quanux
    ```

    This creates the `quanux` environment with Python 3.11 and all required server-side dependencies.
  </Step>

  <Step title="Activate the environment">
    ```bash theme={null}
    conda activate quanux
    ```
  </Step>
</Steps>

<Tip>
  Once the QuanuX channel is added, you can manage upgrades with `conda update quanux`. The Conda environment also gives you direct access to ML tools like PyTorch without isolation conflicts.
</Tip>

***

## Option 2: pip with a virtual environment

Use this path if you're integrating QuanuX into an existing pip-managed project or prefer not to use Conda.

<Steps>
  <Step title="Create and activate a virtual environment">
    ```bash theme={null}
    python3 -m venv .venv
    source .venv/bin/activate
    ```
  </Step>

  <Step title="Install Python dependencies">
    ```bash theme={null}
    pip install -r requirements.txt
    ```

    This installs the full server dependency set, including FastAPI, uvicorn, keyring, the Rithmic async client, NATS, MCP, and AI provider SDKs (OpenAI, Google Generative AI).
  </Step>

  <Step title="Install Node.js dependencies">
    ```bash theme={null}
    pnpm install
    ```
  </Step>
</Steps>

<Warning>
  The `requirements.txt` is the pip fallback. Conda is preferred because it manages native binary dependencies (DuckDB, numpy, polars) more reliably. If you encounter compilation errors with pip, switch to the Conda path.
</Warning>

***

## Option 3: Source build

Use the source build path if you want to contribute to QuanuX, access unreleased features, or build the Tauri desktop app from source.

<Steps>
  <Step title="Clone the repository">
    ```bash theme={null}
    git clone https://github.com/quantdiy/QuanuX.git
    cd QuanuX
    ```
  </Step>

  <Step title="Set up the Python environment">
    <CodeGroup>
      ```bash Conda theme={null}
      conda env create -f environment.yml
      conda activate quanux
      ```

      ```bash venv theme={null}
      python3 -m venv .venv
      source .venv/bin/activate
      pip install -r requirements.txt
      ```
    </CodeGroup>
  </Step>

  <Step title="Install Node.js dependencies">
    ```bash theme={null}
    pnpm install
    ```
  </Step>

  <Step title="Build the Tauri desktop app (optional)">
    To run the desktop cockpit in development mode, you need Rust and Cargo installed. Then:

    ```bash theme={null}
    pnpm -C client/desktop/tauri-app tauri dev
    ```

    To produce a production desktop build:

    ```bash theme={null}
    pnpm -C client/desktop/tauri-app tauri build
    ```
  </Step>
</Steps>

***

## Platform notes

**Linux** is the primary target for execution nodes. All bare-metal execution features — including Solarflare EF\_VI kernel bypass, CPU core pinning, and `quanuxctl nest` deployments — require Linux. Production execution nodes must be compiled natively; cross-compilation and Docker are not supported for execution nodes.

**macOS** is fully supported for running the server, cockpit, and CLI locally. It is the recommended development environment on Apple hardware.

**Windows** is supported for the Tauri desktop cockpit only. Server and CLI functionality on Windows is not officially supported.

***

## Verify your installation

After installing, confirm the server starts correctly:

```bash theme={null}
uvicorn server.app.main:app --host 0.0.0.0 --port 8080
```

You should see uvicorn report that it's listening on `0.0.0.0:8080`. If you see import errors, check that your Python environment is activated and all dependencies from `requirements.txt` or `environment.yml` are installed.

## Next steps

Once QuanuX is installed, follow the [Quickstart](/quickstart) to configure your secrets, launch the cockpit, and run your first backtest.