# Quip Node Manager: Desktop GUI for Running Quip Network Nodes

> Quip Node Manager is a cross-platform desktop application built with Rust and Tauri v2 that manages Quip Network node deployments. It wraps a Docker Compose stack of miner, validator, and dashboard containers behind a GUI, and provides a CLI mode for terminal-based operation.

**QuipNetwork/quip-node-manager** — A simple GUI client to manage a Quip Network node

- Repository: https://github.com/QuipNetwork/quip-node-manager
- Stars: 5,491 · Forks: 18
- Language: Rust
- License: AGPL-3.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/quipnetwork-quip-node-manager

## What Quip Node Manager Is and Who Needs It

Quip Node Manager is a desktop application for running and monitoring Quip Network nodes. It provides a graphical interface for operators who need to start and stop node components, monitor their status, stream logs, configure GPU and network settings, and keep the node software updated without writing Docker commands or editing compose files by hand.

The application targets node operators on the Quip Network, a blockchain or distributed computing network that involves a miner, a validator, and a dashboard running as a Docker Compose stack. The README does not explain the Quip protocol itself; it documents the tool for managing the deployment. Operators on macOS, Linux, and Windows can all use the application, though the available run modes differ by platform.

## Docker and Native Run Modes

Quip Node Manager supports two run modes, and the mode available depends on the platform.

Docker mode is the default on Windows and Linux. It runs the full compose stack: a miner container, a validator container, and a dashboard container. The dashboard image includes an embedded Caddy server as the front door and a log collector; its UI appears inside the application's Dashboard tab through an iframe.

Native mode is available on macOS. It runs a standalone miner binary on the host rather than in a container, while still running the validator and dashboard containers. The native miner communicates with the containerized validator through the `host.docker.internal` hostname.

The image variant (CPU or CUDA) is chosen automatically based on which GPU devices are enabled in the settings. If an NVIDIA device is toggled on, the CUDA image is selected; otherwise the CPU image is used. D-Wave quantum processing unit mining uses the CPU image with an additional `[dwave]` configuration section.

## Installing Quip Node Manager

The quickest installation path on macOS and Linux uses a shell script:

```sh
curl -fsSL https://gitlab.com/quip.network/quip-node-manager/-/raw/main/scripts/install.sh | sh
```

On Windows, the equivalent uses PowerShell:

```powershell
irm https://gitlab.com/quip.network/quip-node-manager/-/raw/main/scripts/install.ps1 | iex
```

For manual installation, download the release from the GitLab releases page. On Linux, the recommended format is an AppImage that runs on any distribution:

```sh
chmod +x quip-node-manager-linux-x86_64.AppImage
./quip-node-manager-linux-x86_64.AppImage
```

A .deb package for Debian and Ubuntu is also available. On macOS, download the .dmg and drag the app to /Applications. On Windows, run the .exe; the publisher is shown as HADAMARD GATE INCORPORATED, and Windows SmartScreen may warn until the certificate builds reputation.

Configuration and data are stored under ~/quip-data/, which is configurable at first boot. The pre-flight checklist runs before the first Start to verify Docker, Compose v2, the node secret, public IP, hostname, and external port reachability.

## Pre-Flight Checklist and Live Log Streaming

Before starting the node stack, Quip Node Manager runs a pre-flight checklist that verifies a set of prerequisites. The checklist confirms that Docker and Compose v2 are available (on Windows it also checks WSL), that the node secret is configured, that the public IP and hostname resolve correctly, and that the required external ports are reachable from outside. Images are not pre-checked; Start always pulls them.

On macOS in Native mode, the checklist additionally verifies that the miner binary is present. When D-Wave QPU mining is configured, it checks that the D-Wave token is present.

Log streaming uses `docker compose logs -f <node>` while the stack is running, and switches to reading `data/node.log` once the node begins writing to that file. Logs appear in a collapsible drawer in the UI. The README notes that container logs attach before stack startup and remain visible even if startup fails or waits on a dependency, which helps diagnose startup problems.

The background update monitor checks for new miner and dashboard image digests and for new application releases every 30 minutes. An optional auto-restart on digest change is configurable, allowing the node to pick up image updates without manual intervention.

## GPU Configuration and D-Wave QPU Support

The GPU configuration panel detects CUDA and Metal devices and presents them with per-device enable/disable toggles and a utilization slider. The yielding mode setting controls how aggressively the miner uses the GPU relative to other workloads on the machine.

D-Wave QPU support is an optional configuration section for operators who want to use a quantum processing unit for mining. The QPU configuration includes a monthly time budget. The README does not document how to obtain D-Wave access or how QPU mining differs from CPU or GPU mining in terms of Quip Network protocol behavior; it documents only the configuration interface.

The CUDA image is selected automatically when any NVIDIA device is enabled; the CPU image is used when only CPU or D-Wave is configured. This means the image variant follows the GPU settings without requiring manual selection.

## Overriding the Compose Stack and Advanced Port Settings

Node Manager writes ~/quip-data/docker-compose.yml from its embedded copy on every Start and Apply, overwriting any manual edits. The correct way to customize the stack is through the override file:

```yaml
services:
  quip-validator:
    environment:
      RUST_LOG: debug
```

Compose automatically discovers and merges docker-compose.override.yml when it exists alongside the base file. Node Manager explicitly passes the override file when present, so the override takes effect. Two behaviors to note: `command:` in an override replaces the entire command list rather than merging with the base, so to change one flag the entire command block must be copied and edited; and the override should reference the staged ~/quip-data/docker-compose.yml rather than the vendor copy in the repository, since staging adds flags the vendor copy does not have.

Advanced settings expose host port configuration for each service. Internal Docker addresses are fixed: quip-validator listens on quip-validator:9944 and quip-miner on quip-miner:8086. The native miner REST API binds to 0.0.0.0:20100 by default so the dashboard's Caddy can reach it through the Docker host gateway.

## Building from Source and the CLI Mode

The application is built with Rust and Tauri v2 for the backend and vanilla HTML/CSS/JavaScript for the frontend. Development dependencies include Rust stable, Bun or Node.js, Docker Compose v2, and platform-specific Tauri v2 prerequisites.

After cloning, the compose stack submodule must be fetched:

```sh
make fetch-submodules
```

This is equivalent to `git submodule update --init --recursive`. Development and production builds then use:

```sh
bun install
bun run dev
bun run build
```

The application also provides a CLI mode for operators who prefer terminal-based operation:

```sh
quip-node-manager --cli
```

The terminal UI supports starting and stopping the stack, running the pre-flight checklist, streaming logs, and editing node configuration. The dashboard, health panel, TLS settings, and in-app updates are available only in the desktop GUI; the CLI mode covers the core operational loop.

TLS for the dashboard is handled by the embedded Caddy server inside the dashboard container. Let's Encrypt or ZeroSSL certificates are configured through the TLS settings in the GUI; setting a DNS name and email is sufficient for automatic certificate provisioning.

## License, Maintenance State, and Alternatives

Quip Node Manager is licensed under AGPL-3.0. The AGPL license requires that if the software is modified and used to provide a service over a network, the modified source must be made available to users of that service. For node operators running the unmodified binary, this has no practical implications. Teams that modify the application before running it should understand the network-use provision.

The last push to the repository was on 2026-09-21, which is recent. The package.json shows version 0.2.10-rc4, indicating the project is approaching but has not yet reached its first stable release.

For operators who prefer command-line management without a GUI, the underlying Docker Compose stack from vendor/nodes.quip.network/ can be driven directly with `docker compose` commands. Node Manager is a convenience layer on top of that stack, not a required component. The README documents this relationship explicitly: compose.rs in the Rust backend simply calls `docker compose` commands to drive the stack.

## Conclusion

Quip Node Manager is the intended interface for operators running a Quip Network node, covering the full lifecycle from pre-flight verification through live log monitoring and background update checks. It is not a tool for developers working on the Quip protocol itself; that work lives in the upstream compose stack at vendor/nodes.quip.network/. Before starting a node, run the pre-flight checklist through the UI, since it verifies Docker, Compose v2, node secret, public IP, hostname, and external port reachability before pulling any images. Configuration overrides belong in ~/quip-data/docker-compose.override.yml rather than in the staged file, which Node Manager overwrites on every Start.

## FAQ

### What Docker Compose version does Quip Node Manager require?

The README requires Docker Compose v2, which is bundled with Docker Desktop. The standalone docker-compose v1 binary is explicitly not supported. On Windows, WSL is also required and verified by the pre-flight checklist.

### Where does Quip Node Manager store its configuration and data?

Configuration, runtime settings, secrets, native binaries, and staged compose files are stored under ~/quip-data/, which is configurable at first boot. The staged docker-compose.yml in that directory is overwritten on every Start, so customizations belong in ~/quip-data/docker-compose.override.yml.

### How do I keep my Quip node updated automatically?

The background update monitor checks for new miner and dashboard image digests and for application releases every 30 minutes. An optional auto-restart on digest change can be enabled in the settings, allowing the node to pick up updated container images without manual action.

## Sources

- [Issues](https://github.com/QuipNetwork/quip-node-manager/issues)
- [License: AGPL-3.0](https://github.com/QuipNetwork/quip-node-manager/blob/main/LICENSE)
- [QuipNetwork/quip-node-manager on GitHub](https://github.com/QuipNetwork/quip-node-manager)
- [README](https://github.com/QuipNetwork/quip-node-manager/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/quipnetwork-quip-node-manager