# Management Dashboards for RocketMQ-Rust: GPUI vs Tauri Implementation Guide

> Explore RocketMQ-Rust management dashboards: GPUI native desktop UI or Tauri with React frontend. Learn how to implement these tools for efficient RocketMQ-Rust management.

- Repository: [mxsm/rocketmq-rust](https://github.com/mxsm/rocketmq-rust)
- Tags: implementation-guide
- Published: 2026-03-07

---

**RocketMQ-Rust provides two official management dashboards—a GPU-accelerated native desktop UI built with GPUI and a cross-platform Tauri application with a React frontend—both sharing core business logic through a common library.**

The `mxsm/rocketmq-rust` repository ships with a workspace-level dashboard suite located in the `rocketmq-dashboard` directory. This suite offers graphical management interfaces for both native-desktop and web-based workflows, enabling administrators to monitor clusters, manage topics, and trace messages without writing code.

## Available Management Dashboards for RocketMQ-Rust

The dashboard workspace organizes three distinct Rust crates under [`rocketmq-dashboard/Cargo.toml`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/Cargo.toml). Each crate serves a specific deployment model while maintaining feature parity through shared components.

### GPUI Dashboard (rocketmq-dashboard-gpui)

The **GPUI Dashboard** is a native desktop UI built with **GPUI**, a GPU-accelerated, pure-Rust UI framework. This implementation targets developers requiring maximum performance and minimal runtime footprint.

The entry point resides in [`rocketmq-dashboard/rocketmq-dashboard-gpui/src/main.rs`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-gpui/src/main.rs), which initializes the GPUI window context and renders the primary interface. Core UI components, including the sidebar navigation and main content panels, are defined in [`rocketmq-dashboard/rocketmq-dashboard-gpui/src/ui/dashboard_view.rs`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-gpui/src/ui/dashboard_view.rs).

### Tauri Dashboard (rocketmq-dashboard-tauri)

The **Tauri Dashboard** provides a cross-platform desktop experience using **Tauri**—a Rust backend paired with a React/TypeScript web frontend. This approach suits teams comfortable with web technologies requiring extensive UI customization.

The frontend entry point is [`rocketmq-dashboard/rocketmq-dashboard-tauri/src/main.tsx`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-tauri/src/main.tsx), which bootstraps the React application. Message inspection features, including trace visualization and dead-letter queue management, are implemented in [`rocketmq-dashboard/rocketmq-dashboard-tauri/src/components/MessageView.tsx`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-tauri/src/components/MessageView.tsx). The Rust backend bridge connecting to the web UI resides in [`rocketmq-dashboard/rocketmq-dashboard-tauri/src-tauri/src/main.rs`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-tauri/src-tauri/src/main.rs).

### Common Library (rocketmq-dashboard-common)

The **Common Library** (`rocketmq-dashboard-common`) encapsulates shared business logic, data models, and API clients. This crate ensures both dashboard implementations offer identical functionality for topic management, consumer group monitoring, and message tracing.

The library exports modules through [`rocketmq-dashboard/rocketmq-dashboard-common/src/lib.rs`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-common/src/lib.rs). The HTTP client implementation for admin API communication is located in [`rocketmq-dashboard/rocketmq-dashboard-common/src/api.rs`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-common/src/api.rs), providing the `DashboardClient` struct used by both UIs.

## Core Features and Capabilities

All management dashboards for RocketMQ-Rust communicate with clusters through standard admin APIs, providing comprehensive operational control:

- **Cluster Overview** – Real-time broker health monitoring, CPU utilization, and memory metrics
- **Topic Management** – Create, delete, and configure topics with partition and replication settings
- **Consumer Group Monitoring** – Track consumer offsets, message lag, and consumption rates
- **Message Query and Trace** – Search, view, and replay messages with end-to-end tracing visualization
- **ACL and Permission Management** – Configure role-based access control for secure cluster operations

## Running the Dashboards

### Launching the GPUI Dashboard

To run the GPU-accelerated native dashboard in development mode:

```bash
cd rocketmq-dashboard
cargo run -p rocketmq-dashboard-gpui

```

The binary initializes a GPUI window connecting to the configured RocketMQ-Rust endpoint (default `http://127.0.0.1:8080`). Configuration options are documented in the [`rocketmq-dashboard/rocketmq-dashboard-gpui/README.md`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard/rocketmq-dashboard-gpui/README.md).

### Launching the Tauri Dashboard

To start the Tauri-based web frontend:

```bash
cd rocketmq-dashboard/rocketmq-dashboard-tauri
npm install
cargo tauri dev

```

This command installs Node.js dependencies (requires Node 24+) and launches the Tauri development server, rendering the React interface in a native window.

## Building Production Binaries

Create optimized release builds for deployment:

```bash

# Build all dashboards with release optimizations

cargo build --workspace --release

# Execute the GPUI release binary

./target/release/rocketmq-dashboard-gpui

# Build Tauri distributable packages (.app, .exe, .deb)

cd rocketmq-dashboard/rocketmq-dashboard-tauri
cargo tauri build

```

## Programmatic API Access

Integration with the dashboard functionality from external Rust applications uses the shared client library:

```rust
use rocketmq_dashboard_common::{api::DashboardClient, models::*};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialize client targeting RocketMQ-Rust admin endpoint
    let client = DashboardClient::new("http://127.0.0.1:8080".parse()?);
    
    // Retrieve topic metadata
    let topics: Vec<TopicInfo> = client.list_topics().await?;
    println!("Cluster topics: {:#?}", topics);
    
    Ok(())
}

```

The `DashboardClient` struct, defined in [`rocketmq-dashboard-common/src/api.rs`](https://github.com/mxsm/rocketmq-rust/blob/main/rocketmq-dashboard-common/src/api.rs), abstracts REST API calls used by both dashboard implementations.

## Summary

- RocketMQ-Rust provides **two official management dashboards**: a GPU-accelerated **GPUI** native app and a **Tauri** web-based desktop app.
- Both implementations share identical functionality through the **`rocketmq-dashboard-common`** library, ensuring consistent topic management, consumer monitoring, and message tracing.
- The **GPUI dashboard** targets performance-critical environments with minimal runtime overhead, while the **Tauri dashboard** offers web-technology flexibility for custom UI development.
- All dashboards communicate via standard admin APIs and can be built as standalone production binaries.

## Frequently Asked Questions

### What are the system requirements for running the RocketMQ-Rust dashboards?

The **GPUI dashboard** requires a GPU-accelerated environment with Vulkan or Metal support, as GPUI renders directly through the graphics pipeline. The **Tauri dashboard** requires Node.js 24+ for development builds, but production binaries bundle the WebKit runtime and run on standard Windows, macOS, or Linux systems without external dependencies.

### Can I use the dashboard functionality programmatically without running the UI?

Yes. The **`rocketmq-dashboard-common`** crate exposes the `DashboardClient` struct, which provides async methods for all management operations. Import this crate directly into your Rust application to query topics, monitor consumer groups, or trace messages without launching the graphical interface.

### How do I configure the dashboards to connect to a remote RocketMQ cluster?

Both dashboards read connection settings from configuration files or environment variables. For the GPUI implementation, modify the endpoint URL in the configuration before running `cargo run -p rocketmq-dashboard-gpui`. For the Tauri implementation, set the admin API URL in the environment or configuration files located in the `src-tauri` directory before executing `cargo tauri dev` or `cargo tauri build`.