QuickRedis is a free Electron desktop client for direct, sentinel and cluster Redis

Three connection modes, and the screenshots show each of them

QuickRedis is a permanently free Redis visualisation and management tool, and the README describes it as an efficiency tool, with the line that when other people are struggling with commands, you are already having tea.

The feature set that matters is the connection modes. It supports direct connection, sentinel, and cluster mode, and the README has a separate configuration screenshot for each: direct-config, sentinel-config and cluster-config. That is the practical reason to consider it, because a client that only speaks to a single Redis endpoint is useless against a sentinel deployment, and the tree of the topics reflects it with cluster-mode, sentinel, redis-cluster and redis-client among the tags.

The key browsing model is a tree. The README shows tree display of keys, and the home screen screenshot is a key of type zset with its value, which tells you the tool opens into a value view rather than into a key list.

The connection management supports multiple directories, copying connections and dragging a connection into a directory, and there is a screenshot of that menu. The tab handling is also shown, with a screenshot for quickly closing multiple tabs, which is a small detail that tells you the tool is used with many connections open at once rather than one at a time.

The application is packaged as an Electron app with a React front end, and the README lists the open source code it builds on: Ant Design, ioredis, React, react-intl-universal, redux and less.

The localisation is described in the README as Simplified Chinese, Traditional Chinese, English, Japanese and French, and the react-intl-universal dependency is the mechanism for that.

Type-specific editors for string, list, set and hash

The screenshots enumerate the per-type editing features, and this is where a Redis GUI earns its keep.

String type management supports JSON formatting of the value, modifying a key, modifying the TTL and deleting a key. List type management supports paginated queries, adding and deleting elements. Set type management supports paginated queries, adding and deleting members. Hash type management supports paginated queries, adding, deleting and modifying fields.

Paginated queries on every collection type is the detail worth noticing. A Redis key holding a large list will not render in a desktop client without paging, and a client that tries to fetch everything first will either hang or exhaust memory. The presence of paging on list, set and hash means the tool is built for keys that are large, which connects to the project's claim of supporting hundreds of millions of keys.

The JSON formatting on string values is the other practical feature. A Redis string is very often a JSON document, and reading it as a raw escaped string in a text box is miserable. Formatting it for display turns the key view into something readable without leaving the app.

There is also a built in command line, shown in its own screenshot. That covers the case where a GUI does not expose the command you need, and it is the standard escape hatch in this category of tool. Monaco Editor is a dependency, along with react-monaco-editor, so the command line and the value editors are built on a real code editor component rather than a plain textarea.

The redis-splitargs dependency is there for parsing a typed command into arguments, and socksv5-fixed is for SOCKS5 proxy support, which matters if the Redis instance is not directly reachable.

Electron and React, with the SSH and proxy escape hatches

The package.json describes the stack precisely, and it explains the practical shape of the tool.

The app is Electron with a React front end. The scripts separate starting the renderer from starting the Electron shell, with start1 running react-app-rewired start and start2 running run-electron on ./public/main.js. The build is the same react-app-rewired build with source maps disabled, and there is one per platform, build:mac, build:linux and build:win, with the Windows one using the set syntax for the environment variable. Packaging is electron-builder with pack:mac, pack:win, pack:linux and pack:all, and the electron-builder configuration sets an appId of com.quick.redis, the product name QuickRedis, maximum compression, and an artifactName of ${productName}-${version}-${os}-${arch}.${ext}.

The dependencies include ssh2, which is how the tool reaches a Redis instance over an SSH tunnel, and socksv5-fixed for proxying. Both are things a GUI needs that a command line client usually gets from the operator's own tooling, and their presence here is a sign that the tool expects to be pointed at instances that are not directly reachable from the desktop.

The redis-splitargs and circular-json dependencies are small utilities, and lodash is used for general object handling, with intl and intl-messageformat providing the internationalisation primitives underneath react-intl-universal.

The repository layout is a Create React App project with react-app-rewired on top, with config-overrides.js at the top level, .env.development and .env.production for the two environments, public/ holding the Electron main file, src/ holding the application, and a snap/ directory for the Snap package, along with a .archcore/ directory and a .trae-html-share-packages/ directory.

Downloading from three places, and the macOS quarantine step

The distribution section is short and worth reading, because it contains the one piece of setup anyone on macOS will hit.

There are three download routes. The Gitee releases page and the GitHub releases page are both linked, and the README also gives a Baidu Netdisk link for Windows, macOS X and Linux. The support channel is also split, with issue trackers on both Gitee and GitHub, and a QQ group number given in the README.

The macOS note is specific. If the app fails to open on mac with the message that it is damaged and cannot be opened and should be moved to the trash, you need to run this command first:

sudo xattr -rd com.apple.quarantine /Applications/QuickRedis.app

That is the standard workaround for a quarantined application, and it appears here because the builds are not signed in a way that satisfies Gatekeeper. It is worth understanding what the command does, because it removes the quarantine flag recursively from the application bundle, which is the flag macOS sets on downloaded files. That is exactly what you want for an app you trust and exactly what you should not do casually for an app you do not.

The README does not describe a signing or notarisation process, and it lists three distribution channels of somewhat different provenance, which is worth weighing before installing. The Gitee host is the primary one, GitHub is the mirror, and the Baidu link is a convenience for users behind networks where the others are slow.

The package.json also carries a copyright line of Copyright 2020 https://quick123.net/, which dates the build tooling.

A development build that you can run yourself

The quick start section is a short list, and it tells you this is a conventional Electron project that you can work on.

For development there are two steps, yarn run start1 and yarn run start2, which match the two script halves in package.json: the React development server and the Electron shell. For packaging there are two steps as well, yarn run build:mac followed by yarn run pack:mac, so the frontend has to be built before electron-builder runs.

The project uses yarn, with a yarn.lock, a .yarnrc and a .yarnrc.yml, and a .yarnclean file. There is no npm lockfile, so the yarn version matters, and the .yarnrc.yml is the modern Yarn configuration file where the yarnPath and nodeLinker settings live.

The test setup is react-app-rewired test, which is the Create React App test runner, and the jest configuration in package.json maps the @/ alias onto src/$, which is the standard Create React App import shortcut.

The repository also has a .gitee/ directory as well as a .github/ one, which means the CI configuration is duplicated across both forges to match where the community actually is.

The ESLint configuration is .eslintrc.json, the old style rather than the flat config, and the licence is MIT with a LICENSE file at the top of the tree. The description in package.json says simply QuickRedis, the homepage is quick123.net, and the author field points at the same site.

Where QuickRedis is the wrong choice

The release history is the first thing to check, and it needs care. The tagged versions are v2.6.3 from May 2022, v2.7.0-alpha from June 2022 and v2.7.1 from July 2022, while the last push to the repository was on 2026-09-20 and the repository is not archived. So there has been recent activity on the source, but the published binaries under those tags are four years old. Whether the download pages serve those old builds or newer ones is not something the README settles.

That matters because this is a tool that connects to production data. A GUI that can delete keys, modify values and change TTLs against a live Redis instance is a privileged application, and the version you run is the version with the bugs. The last release and the last commit are different things here, and the README does not tell you which binary corresponds to which commit.

The second limit is the macOS quarantine workaround. It works, and it is a common request, but removing the quarantine flag from an unsigned application is a decision you are making about a binary whose signature you cannot verify. For a tool that talks to your data stores, that is worth thinking about rather than doing reflexively.

The third is that this is a desktop application and only a desktop application. There is no headless mode, no configuration as code, no way to run the connection checks in a pipeline. The command line inside the GUI helps when you are already looking at the screen; it does not help when the screen is not there. For administration that has to be reproducible, a client library or redis-cli in a script is the tool for the job.

The fourth is the dependency ages. ioredis is at 4.28.5, React tooling is on react-app-rewired with a 0.22-era Monaco Editor, and lodash is at 4.17.19. For a desktop client talking to Redis that is not fatal, since the Redis protocol is stable, but it does mean you are running a stack that will not receive security updates on the same schedule as the rest of your tooling.

Editorial conclusion

QuickRedis suits a developer or operator who wants a graphical Redis client on Windows, macOS or Linux without paying for one, especially when the deployment is sentinel or cluster mode, since the configuration screens cover all three modes. It is the wrong tool if you need a maintained release, because the tagged versions stop at 2.7.1 in 2022 while the repository itself is still being pushed to, and the wrong tool for scripted administration, since it is a desktop application with a GUI and a command line rather than a CI-friendly client. Before installing on macOS, note the quarantine workaround in the README, and check which distribution channel you trust, because the releases are on both Gitee and GitHub as well as a Baidu Netdisk link.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. quick123official/quick_redis_blog on GitHub
4. README
5. Releases