Command palettes are more popular than they’ve ever been. They’re also something of a paradox. Command palettes are ubiquitous while not everywhere their advocates wished they were. They’re a relic of software past, with roots dating back to the 60s, while also being hot new features in the latest products.
Nostalgia in tech is reigniting interest and desire for features we used to see in the past. What’s old is new again — we see it everywhere, from software (the dark mode comeback) to hardware (flip phones and Instamatic cameras). But the popularity of command palettes is more than mere nostalgia; they’re an increasingly essential part of user-centric software.
To understand why, let’s dive into the past, present, and future of the command palette.
First, there was the command line.
A little history lesson
Command line interfaces dominated the early days of computing. Before personal computers gained popularity, they were reserved strictly for those who knew or learned the right commands to operate them. It’s how all operating systems were introduced and used to run. A CLI would get you “inside” programs and files, as well as allow you to configure settings.
Then, the consumerization of personal computers saw the introduction of graphical user interfaces or GUIs. They introduced buttons and laid out most functionality that you’d be expected to use right in the UI.
GUIs were undoubtedly a UX breakthrough when they first emerged with Apple’s Macintosh in 1984. Personal computers were just starting to be adopted by the average household, and their functionality was completely unfamiliar to most. The newbie user needed to understand and learn what a computer could do, and GUIs allowed them to do that through menus, buttons, and widgets. They bridged the gap between techies and non-techies.
Many thought the GUI meant the end of the command line interface. However, the more complex software became, the harder it was to navigate by GUI alone.
AutoCAD is a case in point. The 2D and 3D technical drawing software was first released in 1982. Its extensive functionality led to a complex UI littered with menus, sub-menus, and sub-sub-menus. Over the years, it added a dizzying number of keyboard shortcuts in an attempt to help its users navigate the breadth and depth of its features.
Early text editor Vim led with a command line, too. It used commands like “:wq” to save and exit, which was fast, but it meant you had to learn and remember them. The meme still lives on.
The downside to GUIs was that they hid a lot of power. As Don Norman put it: “GUIs were - and still are - valuable, but they fail to scale to the demands of today's systems.” Yet, for the average consumer, the command line is an overwhelming and mysterious place.
This is what spurred attempts at making the CLI easier to use.
Cisco’s CLI had a tool called Context Sensitive Help that prompted two types of help (word help and command syntax help) when you typed a question mark (?). Even now, Fig, a developer tool, pitches itself as the “next-generation command line.” It embeds into existing command lines and adds suggestions and auto-complete functionality for developers to find the document or command they need faster. Similarly, online IDE, Repl.it, tried merging GUI and CLI elements in what they called a visual command line or CLUI.
Then as search became more commonplace within software we got launchers. Similar to the CLI, they help users find applications and files but do so by entering short abbreviations of the searched item’s name. You might be familiar with the LaunchBar from using it on your MacBook, but that began as a series of shell scripts for NeXTSTEP (from technology company NeXT, which got acquired by Apple) and eventually made its way into Mac OS X in 2001.
What followed was Quicksilver, which began development in 2003 and lives on today as an open-source project on GitHub. The macOS tool lets you perform tasks like sending emails and launching apps using your keyboard only.
As launchers caught on, Apple released its system-wide Spotlight in 2005 as part of Mac OS X Tiger, only to be followed by a myriad of other applications. Like the notorious quest for the perfect note-taking app, launchers keep on launching. From Butler to Alfred and, more recently, Raycast. In fact, Chris Messina, the #1 hunter on Product Hunt, curates a list of launchers that now includes 60+ entries. But, it’s the combination of search and the command line that brings us to the creation of the command palette.
The birth of the command palette
Command palettes are an evolution of traditional command lines and launchers.
One of the earliest examples of the modern command palette we know today comes from Joe Skinner, the creator of Sublime Text, who announced it as part of the Sublime Text 2 beta in 2011.
This was a great step forward in UX for programmers, already comfortable using the command line. It didn’t just help them move faster by using the keyboard only, but it meant they no longer had to memorize all the shortcuts.
Where do we see Command Palettes now?
Command palettes have since become another “it” feature in recent years, particularly when we’re talking about productivity and developer tools. It’s almost expected now that “command + K” or some variation of it will prompt you with a universal search to help you navigate a product. And just like dark mode, the more we keep seeing and using it, the more we require it when trying out new products.
Superhuman’s command palette is maybe one of the most popular out there and played an important role in the consumerization of the command line. For a few years, we witnessed a slew of products trying to replicate the elements that make Superhuman powerful and speedy — shortcuts, search, and keyboard-only commands, “Superhuman for X,” as it were.
The Arc browser also uses the command palette as one of its foundational features. Using cmd + T lets you do almost everything you could with a mouse (but quicker): open and switch new tabs, look for previously visited websites, or access your browser extensions.
Meanwhile, Replit continued to evolve its visual command line, taking on a more typical command palette form, and it’s now used to help users search, find files, manage contributors, and start new projects.
Other new products, like Rewind (which recently bagged $10M in funding, with a16z as lead), want to take on Apple’s Spotlight search and become “the search engine for your life,” allowing you to search for anything on your computer or apps, from things you’ve said or heard in a video meeting, to content on websites you’ve passively browsed.
Why the increasing popularity?
There’s good reason for wanting your product to have a command palette, and it’s not just for the hype. The expectations popular products like Linear have created make command palettes desirable not just for power users but for anyone who has gotten used to using them regularly.
Some of the other advantages command palettes bring when done correctly also include:
- They make the user experience faster. You don't have to take your hands off the keyboard. No clicking into menus, remembering where a feature lives. Just cmd+k and type.
- They aid discoverability. You don't need to know if functionality exists - type what you want and find out if it does and where it is.
- You can always find what you're looking for. Design trends and long-lived software mean that the UI can change. If you’re using a command palette, you don’t need to know where functionality has moved in the UI, you just search for it.
- They make your product look sleeker and more inviting. You can hide functionality from the UI, avoiding cluttering the screen, overwhelming folks with options, or confusing them with multiple sub-menus.
- Accessibility. They can be implemented to help users with disabilities by providing keyboard shortcuts or screen reader support.
What makes a good command palette?
Just adding a command palette won’t make your software automatically better; it must deliver on the needs of your users. Still, command palette implementations that do deliver have some traits in common. For instance:
- Performance. One of the main appeals of command palettes is that they make the user more productive. A great command palette should be responsive and fast so that users can quickly access and execute the commands they need.
- Powerful search. It’s important that your command palette gives users the ability to search content, like documents and files, not just perform actions like launching apps and navigating to different pages.
- Customizability. A command palette should allow users to customize the list of commands displayed by providing options for filtering or sorting.
- Recommendations. These should be based on recent or commonly performed actions to provide suggestions for what the user might be looking to do.
- Fuzzy search and auto-complete. Users shouldn’t have to memorize exact names, but they should be able to type what they think an action or item is called and be presented with options (auto-completed) based on synonyms.
- Discoverability. One of the biggest challenges with implementing a command palette is making sure users know about it. A great command palette should make itself known, as well as provide sufficient context and guidance to help users discover and understand the available commands. This can be achieved through the use of tooltips, explanations, or examples.
From being embraced by developers to being adopted by productivity fiends and now well-known, established products implementing them, command palettes have stood the test of time. But how will they evolve? Will they stay true to CLI’s purposes in the mid-80s, or will they be merged with existing trends in technology?
As more users start shifting their behavior towards search bars rather than exploring menus and buttons, it’s become easier to embed these bars into products. There are open-source libraries like cmdk popping up, as well as dedicated services like CommandBar.
Developments in voice-powered interfaces like Alexa, Siri, or Google Assistant, hint at the possibility of extending that to command palettes. Repl.it, again, is experimenting with voice prompts for its command bar, as well as other AI-enabled functionality that we’ll get to in a second.
The issue with this is that it enhances an already existing challenge: discoverability. How will you know what to say? In a typical command line, you can append options like '-c' to list available commands. Similarly, command palettes filter out irrelevant things, only showing you what you need. But for voice, listing commands can take too long and become annoying, especially if you don’t know what the command you’re looking for is called.
Unless NLP is part of the equation.
OpenAI’s GPT-3 hasn’t just opened doors for fun chatbot conversations to brag about on Twitter, but it’s taken language processing models to a different level.
Instead of knowing exactly what to look for, NLP could help infer what you mean and find the actions closest to that. We’re already seeing language solutions like these applied in many different ways. Replit’s Ghostwriter and GitHub’s CoPilot act as pair programmers, suggesting and predicting what your next line of code might be, as well as auto-complete functions.
For writing and productivity, Notion launched its AI Assist, which activates when you type “/” and lets you perform actions like summarizing or putting together meeting agendas. Other tools like Lex are aimed at becoming a “writing companion” by contributing ideas and getting users out of writer’s block.
This, paired with voice commands, could be a big accessibility win, making it easier for anyone to navigate a product without much prior knowledge. It would make command palettes go a step beyond “keyboard-only,” by finding and executing actions by simply saying things like “open a new document and name it ‘Big Presentation,’”
AI feels like the natural next step for command palettes. Seeing ChatGPT take over the tech conversation does make one wonder, “where does it end?” Will the Internet become one big command palette that has all the answers and performs all the actions? Let’s just hope no one types in
rm -rf. 😵