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

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. 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, 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.

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, 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. The Rust backend bridge connecting to the web UI resides in 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. The HTTP client implementation for admin API communication is located in 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:

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.

Launching the Tauri Dashboard

To start the Tauri-based web frontend:

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:

# 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:

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, 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}