简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is rx?
rx is a minimalist pixel-art editor aimed at artists who prefer keyboard-driven workflows over icon-heavy interfaces. Its distinguishing idea is a modal, command-based UI inspired by vi: instead of hunting through menus, you issue commands, which keeps the canvas and the work in focus. It runs on Linux, macOS and Windows and requires OpenGL 3.3 or later.
What it does
The editor is built for sprite and pixel work rather than general image editing. Notable capabilities include:
- Built-in sprite animation with live preview
- Editing several files at once
- An extensible command system, configurable through a simple text-based language
- Undo/redo for any edit, plus animated GIF export
- Multi-brush synchronous editing and a "pixel-perfect" brush filter
- HiDPI support and UI scaling
The stated goals are a small, hackable codebase, low latency (paint and update under 8ms at 1920x1080 on ordinary hardware), low memory and battery use, and configurability.
Who it suits, and the trade-off
If you already think in modal editors, or you want to script and extend your tooling, rx is a natural fit. If you rely on dense tool palettes, layer panels and hand-holding menus, the sparse UI will feel like a hurdle before it feels like freedom; the command system is the price of admission, not an optional extra.
A practical next step: install it, open one small sprite, and spend a session learning only the commands for drawing, selecting and exporting a GIF. If that loop feels fast, the rest of the workflow will follow. For a broader community of pixel artists to compare notes with, Discord hosts the project's chat space, and GitHub is where the source and releases live.
How do I install rx on my computer?
Install rx by building it from source with Cargo, or by downloading a pre-built binary if one exists for your platform. Per the project page, rx runs on Linux, macOS and Windows and requires OpenGL 3.3 or later.
Install from source
With Rust's cargo and cmake already installed, the documented command is:
cargo install \
--git https://github.com/cloudhead/rx \
--tag v0.5.2
That installs rx under ~/.cargo/bin/rx. If you want it elsewhere, add the --root flag with your target directory, for example /usr/local. On macOS, the page also notes you need Xcode and the Xcode Command Line Tools (xcode-select --install), with CMake available via brew install cmake.
Pre-built binaries
The page points to a binary releases section, but states that only Linux binaries were available at the time of writing. Check that section first if you are on Linux and would rather not compile.
A practical decision
Choose source installation if you want the current stable release and are comfortable with a terminal; choose a binary if one is offered for your OS and you want to skip the toolchain setup. Whichever route you take, confirm your GPU driver supports OpenGL 3.3, since that is the stated requirement. Once installed, the project's guide is the natural next step for learning the modal, command-driven workflow; the source is there if you want to understand or extend it.
What can I do with rx's command system and modal editing?
rx's command system and modal editing are designed to keep the canvas free of toolbars and panels, so most actions are triggered by typing commands rather than clicking buttons. The editor is inspired by vi's modal nature, meaning you switch between different modes for different kinds of work—one mode for navigating and issuing commands, another for painting or manipulating pixels—instead of constantly reaching for menus.
What this enables in practice
- Fast, keyboard-driven workflows. You can keep your hands on the keyboard while drawing, switching tools, and applying edits. This suits artists who already think in shortcuts and want to avoid hunting through palettes.
- A command system you can extend. The command system is described as extensible, and the editor is configurable with a simple text-based language. That means you can bind or define commands to match how you actually work, rather than adapting to a fixed set of menu items.
- Pixel manipulation through a visual mode. Beyond painting, there is a visual mode for manipulating pixels, which points to selection- and transformation-style operations rather than only freehand drawing.
- Composability. Because commands are the primary interface, actions like toggling brush filtering ("pixel-perfect" mode), switching brushes, or working across multiple open files can be strung together as part of a repeatable routine.
Who benefits most
This approach rewards users comfortable with modal editors such as vi or Vim, and anyone who prefers configuring a tool over accepting its defaults. If you mainly draw with a stylus and rarely touch the keyboard, the modal layer may feel like overhead at first; the trade-off is that the interface stays minimal once the commands become muscle memory.
A concrete scenario
Suppose you are animating a small sprite. You might stay in a navigation mode to scrub the live animation preview and jump between frames, then enter a paint mode to adjust a few pixels, apply pixel-perfect filtering to clean up the stroke, and return to navigation—all without moving to a toolbar. The built-in sprite animation support and live preview make this loop practical, and undo/redo covers any edit.
Where to go next
Read the guide linked from the site to learn the actual command names and mode transitions, since those specifics matter more than the general concept. If you want to see how the command system is implemented or extend it yourself, the source is the authoritative reference. For community help and examples, the project points to its Discord. If you are comparing editors, LibreSprite and Aseprite are established pixel-art tools with their own scripting and shortcut models, which can help you judge whether rx's command-first design fits your habits.
Can rx handle sprite animation and export animated GIFs?
Yes. rx includes built-in sprite animation support with live preview, and it can export animated GIFs. Both capabilities are listed among the editor's features on rx.
What that means in practice
- Live preview lets you see the animation play as you edit frames, rather than exporting repeatedly to check timing or motion.
- Animated GIF output covers the most common way pixel art animations are shared on forums, wikis and social platforms.
- Multi-file support matters here: a sprite sheet, a tileset and a character's walk cycle can stay open at once, so you can work on animation alongside the rest of a project.
A concrete workflow: a developer building a 2D game in a framework such as Godot or LÖVE might keep the sprite sheet open in rx, use the animation preview to check a run cycle, then export a GIF for a devlog post. The same file serves both the game build and the public update.
Trade-offs to weigh
GIF is convenient but limited: it supports a restricted palette and no partial transparency, so soft edges and anti-aliased shading can band or fringe. For in-game assets you will usually want a sprite sheet or a PNG sequence instead, and GIF is best treated as the sharing format. If your target engine imports GIFs poorly or not at all, plan on exporting frames separately.
rx's broader design also shapes the animation experience. It is a modal, command-driven editor with as little on-screen UI as possible, aimed at artists and programmers comfortable with that style. If you prefer a conventional toolbar-and-palette interface, the minimalism is a cost rather than a benefit. The animation features themselves are built in, so no plugin is needed.
Next step
Install rx on Linux, macOS or Windows (OpenGL 3.3 or later), open a small multi-frame test sprite, and export a GIF before committing a real project to the format. That single test will show you whether the palette and transparency limits are acceptable for how you plan to publish your animations.
What are the system requirements for running rx?
rx runs on Linux, macOS and Windows, and its one hard graphics requirement is OpenGL 3.3 or later. That is the whole stated baseline: the project lists no minimum CPU, RAM or disk figures, so the practical test is whether your machine's GPU driver exposes OpenGL 3.3.
What each platform implies
- Linux — the most straightforward case; OpenGL 3.3 support is standard on any reasonably recent Mesa or proprietary driver.
- macOS — supported, but building from source also requires Xcode and the Xcode Command Line Tools (
xcode-select --install), plus CMake, installable viabrew install cmake. - Windows — supported, with the same OpenGL 3.3 expectation.
If you install from source rather than grabbing a pre-built binary, you also need the Rust toolchain (the install command uses cargo) and CMake. Pre-built binaries exist, though the page notes that currently only Linux binaries are offered, so macOS and Windows users may need the source route.
How to check before you commit
Confirm your OpenGL version first — on Linux, glxinfo | grep "OpenGL version"; on macOS, the system report's graphics/displays section; on Windows, your GPU vendor's control panel or a utility such as GPU-Z. A result of 3.3 or higher means you clear the only published bar.
Because rx is deliberately minimal and resource-efficient — small memory footprint, low battery drain, sub-8ms paint times targeted at 1920x1080 on commodity hardware — it is a reasonable choice for older laptops and low-power machines, provided the driver is new enough. For a fuller picture of the workflow before installing, the project's own guide and source are the natural next stops, and GitHub hosts the repository referenced in the install instructions.
How can I extend or configure rx for my workflow?
rx is designed to be extended and configured rather than used as a fixed, menu-driven tool. Its command system is the main extension point, and a simple text-based configuration language controls the editor. Because the interface is intentionally minimal and modal like vi, the practical path is to learn the built-in commands first, then bind and combine them around how you actually draw.
Configuring your workflow
Configuration in rx is text-based, so your setup is a file you can version, copy between machines and edit quickly. Typical things to put there are key bindings for the commands you use most, UI scaling for your display, and preferences that remove steps from your normal loop.
A concrete scenario: an animator working at 1920x1080 on a HiDPI laptop could configure UI scaling, bind frame navigation and live-preview toggling to adjacent keys, and keep undo/redo within reach. That turns a repetitive animation pass into a short sequence of keystrokes.
Extending the editor
The command system is described as extensible, meaning new functionality can be added as commands rather than only through built-in menus. The project's stated goal is that if something is not built in, it should be easy to extend. For artists who do not write code, the realistic route is to combine existing commands into configurations; for programmers, the source is available to browse and the codebase is deliberately kept small and hackable.
Features worth configuring around
- Built-in sprite animation with live preview
- Working with multiple files simultaneously
- Undo/redo for any edit
- Animated GIF output
- Multi-brush and synchronous editing
- Brush filtering ("pixel-perfect" mode)
- Visual mode for pixel manipulation
Next step
Install rx from source or a pre-built binary, read the guide, then open your configuration and bind the commands you repeat most. If you get stuck, the community is on Discord. You can also browse the source to understand how commands are defined.
Decision criterion
Choose configuration-only if you want to reshape shortcuts and workflow without touching code. Plan on extending through commands or source if your workflow needs behaviour rx does not ship with. Either way, expect to invest a little time upfront in learning the modal command model; that is the trade-off for the minimal interface and fast, low-distraction painting.
Amazon Route 53
Google Workspace
User reviews (0)