📡 P3X Redis UI: A highly functional and convenient database GUI that fits in your pocket, accessible on both responsive web and desktop applications v2026.4.801

🌌 Bugs are evident™ - MATRIX️
🚧 This project is under active development!
📢 We welcome your feedback and contributions.

NodeJS LTS is supported

🛠️ Built on NodeJs version

v24.14.1

📝 Description

p3x-redis-ui is a versatile Redis GUI that works as a web-based server application or a standalone desktop app. It excels at managing JSON data through an integrated CodeMirror editor with GitHub dark/light themes, supports uploading and downloading binary data, and handles SSH, cluster, and sentinel configurations.

Minimum Node.js Version

v22.0.0

30-Second Docker Quick Start

mkdir -p ./p3x-redis-ui-settings
docker run -d \
  --name p3x-redis-ui \
  -p 7843:7843 \
  -v $PWD/p3x-redis-ui-settings:/settings \
  patrikx3/p3x-redis-ui

Open: http://localhost:7843

Kubernetes / Docker: Always use the latest tag (patrikx3/p3x-redis-ui:latest) with imagePullPolicy: Always. Version-specific tags are available but latest is the recommended and supported tag.

Supported Languages

Switch language in Settings — 54 languages covering 88+ countries:

Arabic (ar), Azerbaijani (az), Belarusian (be), Bengali (bn), Bosnian (bs), Bulgarian (bg), Chinese (zn), Chinese - Hong Kong (zh-HK), Chinese - Taiwan (zh-TW), Croatian (hr), Czech (cs), Danish (da), Dutch (nl), English (en), Estonian (et), Filipino (fil), Finnish (fi), French (fr), Georgian (ka), German (de), Greek (el), Hebrew (he), Hungarian (hu), Armenian (hy), Indonesian (id), Italian (it), Japanese (ja), Kazakh (kk), Khmer (km), Korean (ko), Kyrgyz (ky), Lithuanian (lt), Macedonian (mk), Malay (ms), Nepali (ne), Norwegian (no), Polish (pl), Portuguese (pt-PT), Portuguese - Brazil (pt-BR), Romanian (ro), Russian (ru), Serbian (sr), Sinhala (si), Slovak (sk), Slovenian (sl), Spanish (es), Swahili (sw), Swedish (sv), Tajik (tg), Tamil (ta), Thai (th), Turkish (tr), Ukrainian (uk), Vietnamese (vi)

Screenshots

View screenshots

Demo

Features

Dual GUI: Angular + React

P3X Redis UI was originally built with AngularJS and has been fully migrated to two modern frontends — Angular and React/MUI. You can switch between them live in Settings → GUI.

• Angular is served at /ng/
• React is served at /react/
• / auto-redirects to your last used frontend
• Switch anytime from the GUI toggle in Settings — your preference is remembered
• Both frontends share the same backend, Socket.IO protocol, translation system, themes, and all features
• Works in the Electron desktop app, Docker, and standalone server

AI-Powered Redis Query Translation

• Natural language queries: type plain English (or any language) in the console — if Redis doesn't recognize the command, AI translates it to a valid Redis command and replaces the console input; the command is not executed automatically — you review, edit if needed, and press Enter to run it

• Multi-command AI: AI can generate multiple commands or multi-line EVAL scripts — they are placed in the textarea for review, then executed with Enter

• Input replacement: after AI translation, the console input is replaced with the generated Redis command so you can see exactly what will be executed before running it

• Multilingual: understands 50+ languages, explanations are returned in the language you type in

• Context-aware: sends Redis version, loaded modules, and available RediSearch indexes to the AI for accurate command generation

• Bring your own key: optionally set your own free Groq API key in Settings for better performance (get one at console.groq.com)

• ai: prefix: explicitly trigger AI translation by starting your input with ai: — works when AI is enabled in Settings

• AI toggle in console: when AI is globally enabled in Settings, a slide toggle appears in the console toolbar to control auto-detect behavior:

  • AI ON (default): unrecognized commands automatically try AI translation
  • AI OFF: only the explicit ai: prefix triggers AI — console errors are instant with no Groq round-trip delay
  • When AI is disabled in Settings, the toggle is hidden and all AI features are off

  | Settings AI | Console Toggle | ai: prefix | Auto-detect on errors | |---|---|---|---| | Disabled | Hidden | Off | Off | | Enabled | ON (default) | Works | Works | | Enabled | OFF | Works | Off (instant errors) |

AI Configuration

The AI query translation feature works out of the box — natural language queries are automatically translated to Redis commands via the Groq API.

How It Works

By default, AI queries are routed through network.corifeus.com, which handles the Groq API call. No configuration needed.

If you set your own Groq API key, you can choose to:

• Keep routing via network.corifeus.com (default) — your key is used but queries still go through the proxy for analytics
• Route directly to Groq — toggle "Route via network.corifeus.com" OFF in AI Settings to bypass the proxy entirely

AI Settings in the UI

The Settings page has an AI Settings panel with:

• AI Enabled — toggle AI on/off (enabled by default)
• Route via network.corifeus.com — toggle routing (only visible with a valid Groq API key)
• Groq API Key — set via the Edit button (validated against Groq before saving)

Configuration Options

Recommended: Configure AI settings via the GUI first (Settings > AI Settings). Once configured, you can optionally add groqApiKeyReadonly: true to p3xrs.json or --groq-api-key-readonly CLI flag to lock the settings.

All settings can also be configured via p3xrs.json or CLI options.

Config (p3xrs.json):

{
  "p3xrs": {
    "groqApiKey": "gsk_your_key_here",
    "aiEnabled": true,
    "aiUseOwnKey": false
  }
}

| Key | Type | Default | Description | |-----|------|---------|-------------| | groqApiKey | string | "" | Your Groq API key (get free at console.groq.com) | | aiEnabled | boolean | true | Enable/disable AI auto-detect on unrecognized commands; ai: prefix always works regardless | | aiUseOwnKey | boolean | false | true = route directly to Groq, false = route via network.corifeus.com | | groqApiKeyReadonly | boolean | false | Lock all AI settings (toggles disabled, Edit hidden) |

CLI options:

p3xrs --groq-api-key gsk_your_key_here
p3xrs --groq-api-key-readonly

Readonly Mode

To prevent users from changing AI settings (e.g. on a public instance):

Config (p3xrs.json):

{
  "p3xrs": {
    "groqApiKey": "gsk_your_key_here",
    "groqApiKeyReadonly": true
  }
}

CLI:

p3xrs --groq-api-key gsk_your_key_here --groq-api-key-readonly

Or combine with readonly connections (-r) which also disables AI settings:

p3xrs -r --groq-api-key gsk_your_key_here

Example systemd service (public instance):

[Unit]
Description=p3x-redis-ui
After=network.target

[Service]
Type=simple
User=user
WorkingDirectory=/home/user/p3x-redis-ui
ExecStart=/var/p3x-redis-ui-server/bin/p3xrs.mjs -r --groq-api-key-readonly --config /home/user/p3x-redis-ui/p3xrs.json
Restart=on-abort

[Install]
WantedBy=multi-user.target

Connection Resilience

• Auto-reconnect — when the server disconnects, a spinner overlay appears and Socket.IO automatically retries the connection
• Seamless recovery — when the server comes back, the page reloads and reconnects to the same Redis instance automatically

Compatibility

• Redis 6+ with TLS — see Configuring Redis TLS for setup details
• Pika compatible (not fully optimized)
• SSH tunneling for single instances, cluster, and sentinel
• Environment variables: customize server port and home directory via P3XRS_PORT and P3XRS_DOCKER_HOME

Data Handling

• Auto data decompression — automatically detects and decompresses compressed values stored in Redis. Supports GZIP, ZIP (PKZip), zlib/deflate, Zstandard (zstd), LZ4, Snappy, and Brotli. Shows a compression badge with the algorithm name and space savings ratio. Only decompresses when the result is valid text — binary uploads (e.g., gzipped images) are left untouched. Works for string, list, hash, set, and sorted set values.
• Value format toggle — switch between Raw, JSON, Hex, and Base64 display for all key types (string, hash, list, set, zset, stream); display-only — copy and edit always use the raw original value
• Hex dump viewer — proper hex editor layout with address column, hex bytes (16 per line), and ASCII representation
• JSON pretty-print — auto-formats valid JSON values with indentation
• Base64 encoding — encodes values including Unicode and binary data via TextEncoder
• Binary data: use the download button for binary content; direct text editing is not supported for binary values
• Large values (>256 kB): shown as [object ArrayBuffer]; use binary upload/download
• Clipboard: text can be copied directly; binary data requires the download button

Key Export / Import

• Export: download keys as a JSON file — supports string, list, set, zset, hash, stream, and JSON types with binary data encoded as base64 and TTL preservation
• Search-aware: when a search is active, export only the matching results; otherwise export all keys in the current database
• Import: upload a previously exported JSON file with a preview dialog showing all keys with their translated types, virtual scrolling for large key sets, and conflict handling (overwrite or skip existing keys)
• Hamburger menu: export and import actions are accessible from the ⋮ menu in the tree controls toolbar; the menu label dynamically shows the key count and whether it's exporting all keys or search results
• Bulk delete: delete all keys matching the current search pattern directly from the hamburger menu; when no search is active, deletes all keys using FLUSHDB for efficiency

Real-Time Monitoring (Pulse / Profiler / PubSub)

Three dedicated tabs accessible from the monitoring page:

Pulse — Live Dashboard

• Live metrics: memory usage (used, RSS, peak, fragmentation), ops/sec, connected/blocked clients, hit rate, network I/O, expired/evicted keys — updating every 2 seconds
• uPlot charts: four lightweight canvas charts (~35 KB) for memory, ops/sec, clients, and network I/O with theme-aware colors
• Slow log viewer: recent slow queries with execution duration
• Client list: all connected Redis clients with address, name, database, current command, idle time, and kill button
• Memory top keys: top 20 biggest keys by memory usage with byte sizes
• Auto-refresh: toggle auto-polling for client list and memory top keys
• Pause/resume: pause live updates without leaving the page
• Export: download overview data, charts (PNG), slow log, client list, and top keys as text files
• Theme + language reactive: charts reinitialize on theme or language change

Profiler — Real-Time Command Stream

• Redis MONITOR: streams every command executed on the server in real time via a dedicated Redis connection
• Command display: timestamp (ms precision), database number, source IP, and full command with arguments
• Performance: renders max 66 DOM entries for smooth scrolling, stores up to 10,000 entries in memory
• Persistence: last 100 entries saved to localStorage
• Export: download all entries as a text file

PubSub — Channel Message Monitoring

• Pattern subscription: subscribe with configurable glob patterns (default * for all channels) via PSUBSCRIBE
• Message display: timestamp, channel name, and full message content in real time
• Restart: re-subscribe with a new pattern without leaving the page
• Performance: same 66 DOM / 10,000 memory / 100 localStorage limits as Profiler
• Export: download all entries as a text file

Analysis — Memory Analysis Dashboard

• One-click snapshot: capture the full state of your Redis server at a point in time — type distribution, memory allocation per namespace, key expiration stats, and INFO memory breakdown
• Type distribution chart: canvas bar chart showing how many keys and how much memory each data type (string, hash, list, set, zset, stream) uses
• Memory by prefix: groups keys by their first : segment and ranks prefixes by total memory — quickly find which namespace is consuming the most resources
• Key expiration overview: shows the count of keys with TTL vs persistent keys, plus the average TTL across all expiring keys (formatted with humanize-duration)
• Memory breakdown: total, RSS, peak, overhead, dataset, Lua, fragmentation ratio, and allocator — all from INFO memory
• Server info header: Redis version, mode (standalone/cluster/sentinel), and uptime displayed in the accordion header
• Configurable scan: adjust "Top N" and "Max Scan Keys" to control scan depth; the UI shows how many keys were sampled out of the total database size
• Export All (ZIP): download a complete analysis bundle as a ZIP file ({connection}-analysis.zip) containing the full text report and all chart images (PNG) — useful for sharing with your team or attaching to incident reports when investigating server issues
• Chart export: each chart accordion has its own Export button to download individual charts as PNG
• Theme-aware: bar charts use CSS custom property colors and automatically redraw on theme or window resize

User Interface

• Responsive design: works on phones, tablets, and desktops
• 7 themes: Light, Enterprise, Redis (light) + Dark, Dark Neu, Darko Bluo, Matrix (dark) — with auto-switch that follows your system's dark/light preference in real time
• Theme auto-switch: defaults to system preference on first visit; manually selecting a theme overrides auto mode
• Info page: dedicated page with keyboard shortcuts reference, about section (version, Redis info, links), and supported languages list
• Command palette: VS Code-style quick command palette (Ctrl+K in Electron) with search and keyboard navigation
• Desktop shortcuts: press ALT to access menus in the desktop version
• Tree view: adjustable key count (100–100,000) with virtual scrolling for performance

Keyboard Shortcuts (Electron Desktop)

| Shortcut | Action | |----------|--------| | Ctrl+R / F5 | Refresh current view | | Ctrl+F | Focus search input | | Ctrl+N | New key dialog | | Ctrl+K | Command palette | | Ctrl+D | Disconnect |

Connection Management

• Connection groups: organize connections into named groups with collapsible headers in Settings
• Drag-and-drop: reorder connections within a group and reorder groups themselves by dragging headers
• Group toggle: enable/disable grouped view with a single click — persisted in localStorage
• Group field: optional group name in the connection dialog with autocomplete from existing groups

Console and Search

• Multi-line input: the console uses a textarea that supports multi-line commands
  • Shift+Enter inserts a new line, Enter executes
  • Multiple commands (one per line) are executed sequentially
  • Multi-line EVAL/EVALSHA scripts are sent as a single command — Lua newlines are preserved
  • The textarea auto-grows up to 3 lines when focused, with a scrollbar for longer content
  • On blur the textarea collapses to a single line to keep the output visible
• Command history: Shift+ArrowUp/Down navigates history (plain arrows scroll the textarea)
• AI multi-line: AI-generated commands can be multiple lines — they are placed in the textarea for review before execution
• Channel monitoring: toggle monitoring for all channel messages via a checkbox; the last 20 entries are stored in local storage
• Database selection: choose databases via the console or dropdown (shows empty/filled status)
• Search modes: client-side for small key sets, server-side for large key sets; search by prefix or substring

Networking

• Sub-directory support: use Nginx/Ingress path rewriting — see Issue #43
• Cluster support: continuously improving, with significant contributions by @devthejo

Modern Dual Frontend Architecture

The UI has been fully migrated from AngularJS (1.x) to two modern frontends — Angular and React/MUI — both at full feature parity:

Angular frontend (/ng/):

• Angular CLI with esbuild — near-instant dev recompiles and optimized production builds
• CDK virtual scrolling — tree view renders only visible rows for O(visible) DOM performance
• Standalone components — Angular signals, Angular Material, and lazy-loaded routes

React frontend (/react/):

• Zustand state management — lightweight stores replacing Angular services
• @tanstack/react-virtual — virtual scrolling for tree view and large lists
• MUI (Material UI) — React component library matching Angular Material's look and feel
• Vite — instant dev server startup and fast production builds

Shared across both:

• Web Worker tree building — key sorting and tree construction run off the main thread, keeping the UI responsive with large key sets
• Same Socket.IO protocol — both frontends use the identical backend API
• Same translation system — 54 languages shared from a single source
• Same 7 themes — 4 dark + 3 light, with auto system preference detection
• E2E tested — Playwright tests run against both frontends in parallel

RediSearch Full-Text Search

• Search page: full-text search UI with index selector, query input, and paginated results — only visible when RediSearch module is detected
• Index management: create indexes with schema builder (TEXT, NUMERIC, TAG, GEO, VECTOR fields), drop indexes with confirmation
• Index info: view index metadata and statistics after running a search
• Module-aware: header button automatically appears when the search module is loaded (Redis 8+ or Redis Stack)

RedisTimeSeries Visualization

• Module auto-detection — TimeSeries UI automatically appears when the timeseries module is loaded (Redis Stack or Redis 8+)
• Interactive line chart — uPlot canvas chart with theme-aware colors (dark/light), responsive resizing, and locale-aware time formatting via native Intl
• Live auto-refresh — toggle auto-polling (10-second interval) to watch incoming data in real time
• Reactive inputs — chart auto-reloads on any input change (from/to, aggregation, overlay, label filter) with debounced updates
• Time range & aggregation — filter by from/to timestamps, apply aggregation functions (avg, min, max, sum, count, first, last, range, std.p, std.s, var.p, var.s) with configurable time buckets
• Data point management — add, edit, and delete individual data points with confirmation dialogs; inline add form directly below the chart
• Bulk edit — edit all data points at once via the Edit button in the chart header; monospace textarea with timestamp value per line; * timestamps are auto-spread by a configurable interval (1s to 24h)
• Bulk generate on create — toggle "Bulk generate" in the Add Key dialog to create a new timeseries key with multiple data points at once using the formula generator
• Formula generator — generate test data with mathematical formulas (sin, cos, linear, random, sawtooth) with configurable point count, amplitude, and offset
• TS.INFO panel — view retention, total samples, memory usage, chunk info, duplicate policy, labels, and compaction rules in a settings-style mat-list
• Labels editor — edit retention, duplicate policy, and labels on existing keys via TS.ALTER; labels are also editable from the Edit dialog
• Default labels — keys created from the GUI automatically get a key=<keyname> label for discoverability; keys without labels get the default label assigned on first view
• Multiple series overlay — overlay additional timeseries keys on the same chart by entering comma-separated key names
• TS.MRANGE label filter — query across multiple keys by label filter (e.g. sensor=temp) and overlay all matching series on the chart with different colors
• Export chart as PNG — download the chart as a PNG image with proper background (dark/light aware), title, and color legend
• Key creation — create new timeseries keys with configurable retention, duplicate policy (LAST, FIRST, MIN, MAX, SUM, BLOCK), and labels
• Tree integration — timeseries keys show with a chart-area icon and display the data point count (totalSamples) in the tree view
• Theme + language reactive — charts reinitialize on theme or language change
• No external date library — all date formatting uses native Intl.DateTimeFormat, no dayjs dependency for the timeseries component

Redis 8 Module Support (ReJSON)

• ReJSON (JSON data type) — view, create, edit, format, copy, and download JSON documents stored with JSON.SET
• Module auto-detection — available modules are detected on connection via MODULE LIST
• JSON keys appear in the tree with a </> icon; JSON type is available in the "Add Key" dialog when the module is detected
• Inline JSON tree — JSON keys display as an expandable/collapsible tree with syntax coloring
• CodeMirror editor — edit JSON documents with syntax highlighting, GitHub dark/light themes, line wrapping toggle, and code folding

RedisBloom Probabilistic Data Structures

• Full support for 5 types — Bloom filter, Cuckoo filter, Top-K, Count-Min Sketch, and T-Digest
• Module auto-detection — probabilistic types appear when the bf (RedisBloom) module is detected via MODULE LIST
• Info display — click any probabilistic key to see its metadata (capacity, size, error rate, items inserted, etc.) in a clean card layout
• Inline actions — add items, check membership (Bloom/Cuckoo), query counts (CMS), query quantiles (T-Digest), and list top items (Top-K) — all from the key view
• Key creation — create new keys with smart defaults pre-filled (error rate, capacity, K, width, depth, decay, compression)
• Tree integration — each type has its own icon (filter, trophy, chart) and shows item count in the tree view
• Console hints — full autocomplete support for all BF., CF., TOPK., CMS., and TDIGEST.* commands
• AI query support — the AI console understands all RedisBloom types and commands

Redis 8 VectorSet Support

• Native vector type — full support for Redis 8's built-in VECTORSET data type (no module required)
• Vector info — view metadata (dimensions, element count, quantization, projection) via VINFO
• Element browser — paginated list of all vector elements with search, attribute inspection, and delete actions
• Similarity search — search by element name or by raw vector with configurable COUNT; results displayed with similarity scores
• Attribute viewer — inspect VGETATTR attributes on individual elements via info icon + toast
• Add elements — inline form to add new vector elements with VADD (element name, vector, optional attributes)
• Key creation — create new VectorSet keys from the "Add Key" dialog with dimension and initial element
• Tree integration — VectorSet keys show with a data-array icon and display element count (VCARD) in the tree view
• Console hints — autocomplete for VADD, VSIM, VCARD, VDIM, VGETATTR, VSETATTR, VREM, VINFO, VLINKS
• VSIM IN filter (Redis 8.2+) — filter expression input for similarity search, narrow results by attribute values
• AI query support — the AI console understands VectorSet types and commands

Redis 8.x Advanced Features

• Per-field hash TTL (Redis 8.0+) — set expiration on individual hash fields via HEXPIRE; schedule icon per field row with live countdown, color-coded (green >1h, yellow <1h, red <5min, pulsing <30s), tooltip with humanized duration; auto-refresh when a field expires
• String digest (Redis 8.4+) — view the hash digest of any string key value via the DIGEST command; one-click button in string key actions
• Hybrid search (Redis 8.4+) — toggle FT.HYBRID mode on the search page to combine text queries with vector similarity using Reciprocal Rank Fusion; requires a RediSearch index with a VECTOR field
• Cluster slot stats (Redis 8.2+) — monitoring dashboard accordion showing top slots by key count, CPU time, or memory usage via CLUSTER SLOT-STATS; only visible in cluster mode
• Console command hints — autocomplete for all new Redis 8.0–8.6 commands: HGETEX, HSETEX, HGETDEL, HTTL, HEXPIRE, HPERSIST, MSETEX, XDELEX, XCFGSET, DIGEST, FT.HYBRID, CLUSTER SLOT-STATS, CLUSTER MIGRATION
• AI query support — AI prompt updated with all Redis 8.0–8.6 commands; Redis server version now correctly sent to AI for version-aware command generation
• Version-gated UI — all Redis 8.x features automatically appear/hide based on the connected Redis server version

ES Modules Backend

The server codebase has been fully migrated from CommonJS to ES Modules (.mjs), enabling native Node.js ESM support and better tree-shaking.

Security

• Secure configuration: passwords and sensitive data are protected with unique identifiers for both main and node configurations

Important Notice

Do not manually create the configuration JSON file with a text editor. Use the GUI to generate it instead — the resulting file can then be deployed to systems like Kubernetes.

Optional HTTP Basic Authentication

Protect both HTTP routes and Socket.IO with HTTP Basic authentication.

Config (p3xrs.json):

{
  "p3xrs": {
    "httpAuth": {
      "enabled": true,
      "username": "admin",
      "passwordHash": "$2b$10$..."
    }
  }
}

Generate a BCrypt password hash:

node ./node_modules/p3x-redis-ui-server/bin/bcrypt-password.js -p myplainpass

Environment variables:

• HTTP_USER
• HTTP_PASSWORD
• HTTP_PASSWORD_HASH
• HTTP_PASSWORD_HASH_FILE
• HTTP_AUTH_ENABLED (true|false)

CLI options:

• --http-auth-enable
• --http-auth-disable
• --http-auth-username
• --http-auth-password
• --http-auth-password-hash
• --http-auth-password-hash-file

Notes:

• passwordHash is preferred over plain password.
• Use HTTPS or a reverse proxy with TLS when HTTP auth is enabled.

All Features Are Free

All features including SSH tunneling, Cluster/Sentinel, ReJSON, binary upload/download, and readonly connections are available for free. No license required.

Live Demo

Try the latest version at p3x.redis.patrikx3.com.

• Daily data reset: the Redis database restores certain datasets every morning (CET)
• Brief downtime: occasional ~1 second interruptions may occur due to automatic updates from Git changes
• Version differences: the live instance may differ from the GitHub or NPM release; updates are typically published monthly

Installation

Releases / Downloads

https://github.com/patrikx3/redis-ui/releases

CLI (Node.js / NPM)

Start the server via Node.js/NPM and access it in a browser.

npm install -g p3x-redis-ui
p3xrs

Open: http://localhost:7843

CLI Options

Usage: p3xrs [options]

Options:
  -V, --version                           output the version number
  -c, --config [config]                   Set the p3xr.json p3x-redis-ui-server configuration, see more help in p3x-redis-ui-server
  -r, --readonly-connections              Set the connections to be readonly, no adding, saving or delete a connection
  -n, --connections-file-name [filename]  Set the connections file name, overrides default .p3xrs-conns.json
  --http-auth-enable                      Enable HTTP Basic auth
  --http-auth-disable                     Disable HTTP Basic auth
  --http-auth-username [username]         HTTP Basic auth username
  --http-auth-password [password]         HTTP Basic auth plain password
  --http-auth-password-hash [hash]        HTTP Basic auth bcrypt password hash
  --http-auth-password-hash-file [file]   Read HTTP Basic auth bcrypt password hash from file
  --groq-api-key [key]                    Groq API key for AI-powered Redis query translation (get a free key at console.groq.com)
  --groq-api-key-readonly                 Prevent users from changing the Groq API key via the UI
  -h, --help                              display help for command

Server startup guide

Config file reference

Connection config reference

Example connection config

Docker

https://hub.docker.com/r/patrikx3/p3x-redis-ui

Compose

https://github.com/patrikx3/redis-ui/blob/master/docker-compose.yml

wget https://raw.githubusercontent.com/patrikx3/redis-ui/master/docker-compose.yml
# Adjust the settings folder path in docker-compose.yml as needed.
docker-compose up

Standalone

mkdir -p ./p3x-redis-ui-settings
docker run -v $PWD/p3x-redis-ui-settings:/settings -h docker-p3x-redis-ui -p 7843:7843 -t -i patrikx3/p3x-redis-ui

The GUI will be at http://localhost:7843

Health Check

The Docker image includes a built-in HEALTHCHECK that polls /health every 30 seconds. Container orchestrators (Docker Compose, Swarm, etc.) will automatically mark the container as unhealthy if the server stops responding.

Graceful Shutdown

The server handles SIGTERM and SIGINT signals gracefully — it closes Socket.IO connections, disconnects all Redis clients, and shuts down the HTTP server before exiting.

Kubernetes

Raw Manifests

https://github.com/patrikx3/redis-ui/blob/master/k8s/manifests

kubectl apply -f namespace.yaml
# Edit redis host and password in configmap.yaml first
kubectl apply -f configmap.yaml
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml

The manifests and Helm chart include liveness and readiness probes — both use GET /health to verify the server is responding.

Helm Chart

https://github.com/patrikx3/redis-ui/blob/master/k8s/chart

helm template -f values.yaml release --namespace namespace . > generated.yaml
kubectl apply -f generated.yaml

Desktop Applications

macOS

Supports both Intel and Apple Silicon builds. If you download the zip for the arm64 version, remove the quarantine attribute:

sudo xattr -rd com.apple.quarantine P3X-Redis-UI.app

Snap

Available for x64 and arm64 architectures.

sudo snap install p3x-redis-ui

Flatpak

Download from the releases page and install:

wget https://github.com/patrikx3/redis-ui/releases/download/v${VERSION}/P3X-Redis-UI-${VERSION}-x86_64.flatpak
flatpak install ./P3X-Redis-UI-${VERSION}-x86_64.flatpak
flatpak run com.patrikx3.redis_ui

The application menu is automatically integrated.

AppImage, deb, rpm

These packages support automatic updates.

After downloading the AppImage, make it executable:

mkdir -p $HOME/opt
mv ~/Downloads/p3x-redis-ui-a.b.c-x86_64.AppImage $HOME/opt/
chmod +x $HOME/opt/p3x-redis-ui-a.b.c-x86_64.AppImage
$HOME/opt/p3x-redis-ui-a.b.c-x86_64.AppImage &

ElectronJs

The app is listed on ElectronJs Apps — search for P3X.

Architecture

This application uses Socket.IO instead of REST for client-server communication. While unconventional, Socket.IO provides better responsiveness by avoiding HTTP protocol overhead, resulting in a smoother interaction experience.

REST vs WebSocket benchmarks

Communication Flow

Browser / Electron App / VS Code Extension
        ↓
redis-ui-material
  ├── Angular frontend (/ng/)  — Angular + Angular Material + Webpack
  └── React frontend (/react/) — React + MUI + Vite + Zustand
        ↓ Socket.IO + HTTP
redis-ui-server (Express + ioredis)
        ↓
Redis Instance (standalone / cluster / sentinel, optional SSH tunnel)

Related Repositories

| Repository | Description | |------------|-------------| | p3x-redis-ui | Electron desktop app + CLI (this repo) | | p3x-redis-ui-server | HTTP + Socket.IO server backend | | p3x-redis-ui-material | Angular + React frontends |

Adoption Notes

redis-commander has more Docker pulls due to its longer history and presence in tutorials/CI pipelines. p3x-redis-ui adoption continues to grow steadily.

Detailed analysis and action plan

Change Log

View change log

Contributors

View contributors

Links

P3X Redis UI playground Corifeus P3X Redis UI AlternativeTo NPM Snap Store GitHub Pages Web development Webfejlesztés

🚀 Quick and Affordable Web Development Services

If you want to quickly and affordably develop your next digital project, visit corifeus.eu for expert solutions tailored to your needs.

🌐 Powerful Online Networking Tool

Discover the powerful and free online networking tool at network.corifeus.com.

🆓 Free
Designed for professionals and enthusiasts, this tool provides essential features for network analysis, troubleshooting, and management.
Additionally, it offers tools for:

• 📡 Monitoring TCP, HTTP, and Ping to ensure optimal network performance and reliability.
• 📊 Status page management to track uptime, performance, and incidents in real time with customizable dashboards.

All these features are completely free to use.

❤️ Support Our Open-Source Project

If you appreciate our work, consider ⭐ starring this repository or 💰 making a donation to support server maintenance and ongoing development. Your support means the world to us—thank you!

🌍 About My Domains

All my domains, including patrikx3.com, corifeus.eu, and corifeus.com, are developed in my spare time. While you may encounter minor errors, the sites are generally stable and fully functional.

📈 Versioning Policy

Version Structure: We follow a Major.Minor.Patch versioning scheme:

• Major: 📅 Corresponds to the current year.
• Minor: 🌓 Set as 4 for releases from January to June, and 10 for July to December.
• Patch: 🔧 Incremental, updated with each build.

🚨 Important Changes: Any breaking changes are prominently noted in the readme to keep you informed.

P3X-REDIS-UI Build v2026.4.801