albertlauncher.github.io

Albert is a keyboard launcher for your machine: you type a query, and it gives you unified, efficient access to apps, files, and other actions without leaving the keyboard. It is written in C++/Qt and built on a plugin architecture, so it can work as a simple app launcher or as a full system command palette. It suits users who want fast keyboard-driven access and are comfortable extending functionality through plugins or Python modules.

Core idea: one input, many actions

Albert's job is to turn a keystroke into a result. Instead of hunting through menus or remembering where a setting lives, you trigger Albert, type what you want, and pick from the matches. The site describes this as "unified and efficient access to your machine."

The same input surface can serve different roles depending on which plugins you enable:

• App launcher — start installed programs by name.
• System command palette — run broader machine actions through plugins.
• Extension host — add frontends or functional extensions, including embedded Python modules or CGI-style extensions in any language.

Why it is built the way it is

Performance

Speed is a primary design goal. The site frames this around muscle memory: if you can type 200+ KPM, Albert is designed to keep up. In practice, that means the launcher should feel responsive rather than making you wait for results.

Plugin-based flexibility

The plugin system is what separates a launcher from a command palette. Rather than hard-coding every feature, Albert lets plugins define functionality. You customize by choosing and configuring plugins, not by hoping the core app covers your exact workflow.

Extensibility with simple APIs

Albert provides APIs intended to be simple and easy to learn, plus utilities for common tasks with minimal code. If a built-in plugin does not cover your case, you can implement an extension using embedded Python modules or a CGI approach in any language.

Curated plugins ("batteries included")

Albert ships with a curated collection of peer-reviewed, actively maintained plugins. The site's claim is no searching, no duplicates, no broken code, no risks — it works out of the box. Treat that as the project's positioning: the value is a maintained default set rather than a plugin marketplace you have to vet yourself.

Who it fits, and when to look elsewhere

How to evaluate it for your workflow

1. Identify your top three repeated actions — for example, launching an editor, opening a project folder, or running a system command.
2. Check whether the bundled plugin collection covers them. The site emphasizes a curated, peer-reviewed set, so start there rather than assuming you must build extensions.
3. Test the speed claim against your own typing. If results lag behind your input, the launcher is not meeting its core design goal for you.
4. Decide whether you need extensions. If your actions are covered, use it as an app launcher. If not, plan for a Python module or CGI-style extension.

The main decision is not whether Albert can launch apps — it is whether you want a launcher you can extend into a command palette, and whether the curated plugin set already matches the actions you repeat.

Albert's plugin system is the mechanism that turns a keyboard launcher into a customizable command palette. The core application is written in C++/Qt and handles the launcher shell — hotkey, query input, result list, and action execution. Everything beyond that shell is a plugin. Plugins can either create frontends (the interface you interact with) or add functional extensions (the things Albert can find and do). Extensions can be written as embedded Python modules or exposed through a CGI-style approach in any language you choose.

The two roles a plugin can play

The site describes the architecture as "plugin based" and says plugins "can be used to create frontends or functional extensions." That distinction matters when you plan your own integration:

For most users, the practical question is the second row: how do I make Albert search my own data or trigger my own actions? That is an extension, and the architecture gives you two implementation routes.

Route 1: embedded Python modules

The site states that extensions "can also be implemented using embedded Python modules." The word embedded is the key detail: Python runs inside Albert's process rather than as a separate program. In practice this means your extension is a module Albert loads, and the launcher calls into it when a query arrives.

This route suits you if:

• You want the shortest path from idea to working extension.
• Your logic is self-contained — querying a local file, calling a small API, computing a result.
• You are comfortable with Python and prefer not to manage a separate process.

The site also says Albert "offers APIs designed to be simple and easy to learn" and "provides a set of powerful utilities" so common tasks need minimal code. Those utilities are what you should look for first before writing plumbing yourself.

Route 2: CGI approach in any language

The second route is a "CGI approach in any language you want." Here the extension is not loaded into Albert's process; instead Albert invokes it in the CGI style — the launcher passes the query in, your program writes a response out, and Albert renders the results. The language is your choice because the contract is the CGI interface, not a language binding.

Choose this route when:

• Your extension is already a script or binary in another language (Go, Rust, a shell script, Node).
• You want process isolation — a crash or hang in your extension should not take the launcher down with it.
• You are wrapping an existing command-line tool and want its output to appear as Albert results.

The trade-off is the interface boundary: you are responsible for formatting output correctly, and you give up direct access to in-process APIs. The Python route is more tightly integrated; the CGI route is more portable.

What "flexibility" actually buys you

The site frames the plugin system as the reason Albert "could be your go-to app launcher or a full-blown system command palette." That is the concrete payoff of the frontend/extension split: the same core can present very different products depending on which plugins are loaded. A minimal setup behaves like a fast app launcher; adding extensions turns it into a place where you run system commands, query services, and trigger workflows from one input field.

Two supporting claims from the site are worth noting because they affect day-to-day use rather than architecture:

• Performance is a primary design goal. The site says Albert is "designed to be fast" and can keep up with users who type at 200+ KPM. A plugin architecture can undermine speed if extensions are slow, so treat extension latency as part of your design.
• A curated plugin collection ships with it. The site describes "a curated collection of peer-reviewed, actively maintained plugins" with "no searching, no duplicates, no broken code." For most users, the first step is not writing an extension but checking whether a maintained plugin already covers the task.

A practical way to decide

1. Check the bundled collection first. If a maintained plugin does the job, use it — the site explicitly positions the included set as working out of the box.
2. If you need custom behavior, start with Python. It is the lower-friction route and gives you Albert's APIs and utilities directly.
3. Move to CGI only when you have a reason. An existing tool in another language, or a need for process isolation, are good reasons; novelty is not.
4. Test with realistic query volume. Because speed is a stated design goal, measure how your extension behaves under fast, repeated typing rather than a single slow query.

The one thing the site does not specify is the exact plugin API surface or the precise CGI request/response format. Those details belong in the project's developer documentation, and you should confirm them there before writing code rather than assuming a shape from the architecture description alone.

Albert ships with a curated, peer-reviewed collection of plugins that are actively maintained, and the project states it works out of the box—no searching, no duplicates, no broken code. The site does not publish a named list of every bundled plugin, so the honest answer is: you get a maintained default set rather than a documented catalog, and you should confirm the exact contents in the app after install.

What the site actually promises

The "Batteries included" section of albertlauncher.github.io makes four claims:

• The bundled plugins are curated — someone has selected them deliberately.
• They are peer-reviewed — not just dumped in.
• They are actively maintained — they aren't abandoned code.
• The result is no searching, no duplicates, no broken code, no risks — "It just works out of the box."

That is a quality statement about the default set, not an inventory. If you need to know whether a specific capability (web search, calculator, file browsing, etc.) is present, treat the site as silent on it and check the installed plugin list instead.

Why "out of the box" matters here

Albert is a keyboard launcher written in C++/Qt with a plugin-based architecture. The same architecture that lets it be "your go-to app launcher or a full-blown system command palette" also means functionality is modular: what you can do depends on which plugins are loaded. The bundled set is the baseline you get before adding anything.

Two extension paths exist beyond the default plugins, per the site:

The site also notes the plugin architecture supports frontends as well as functional extensions, and that the APIs are "simple and easy to learn" with "powerful utilities" for common tasks.

How to verify what you actually have

Because no list is published, verify locally:

1. Install Albert and launch it.
2. Open the settings/preferences area and find the plugins or extensions section.
3. Read the list of loaded plugins and their descriptions.
4. Note which are enabled by default versus available but off.

Expected result: a list matching the "curated collection" description. If a plugin you expected is missing, it may exist but be disabled, or it may not be part of the bundled set.

Common sticking points

• Assuming a plugin exists because a similar launcher has it. The site makes no per-plugin claims; don't infer from competitors.
• Confusing bundled plugins with Python/CGI extensions. The latter are things you add or write, not part of the default set.
• Expecting a download step. The site's framing is that the default set is already there; if you find yourself hunting for a plugin marketplace, re-read the "no searching" claim and check settings first.

The practical takeaway

If your question is "do I need to assemble a plugin set myself?" — no, per the site. Albert is designed to be useful immediately with a maintained default collection, and you extend it only when you want something specific via Python modules or CGI. If your question is "is plugin X included?" — the site won't tell you; the in-app plugin list will.

Albert is designed for speed as one of its primary goals, and the project states it can keep up with muscle memory that reaches 200+ KPM (keystrokes per minute). That claim is about responsiveness under fast, repeated keyboard input rather than a published benchmark, so treat it as a design target: Albert is built to feel immediate when you launch it, type a query, and trigger a result without breaking your typing rhythm.

What "fast" means for a keyboard launcher

A launcher's speed is felt in three places, and Albert's design addresses each:

• Summon latency — how quickly the launcher appears after its hotkey. A launcher that lags here interrupts muscle memory before you type anything.
• Query responsiveness — how quickly results filter as you type. This is where high KPM users notice stutter first.
• Action execution — how fast the selected item runs once you confirm it.

Albert's site frames performance as a core design goal rather than an add-on, and pairs it with an efficiency principle: technology, design, tooling, and distribution decisions are all made with efficiency in mind. In practice, that means the launcher is written in C++/Qt and keeps its core lightweight, with functionality pushed into plugins.

Why the plugin architecture matters for speed

Albert is a plugin-based launcher: the core handles the hotkey, the input field, and result display, while plugins supply the actual results (apps, files, calculations, and so on). This split is what lets it stay fast while remaining flexible:

• The core stays small, so summoning and typing stay responsive.
• Plugins load and query independently, so a heavy extension doesn't have to slow the core loop.
• The same architecture lets Albert act as either a simple app launcher or a fuller system command palette, depending on which plugins you enable.

The trade-off is that perceived speed depends partly on your plugin set. A curated, actively maintained plugin collection ships with Albert ("batteries included," peer-reviewed, no duplicates or broken code), which reduces the risk of a poorly behaved extension dragging down response time.

How to check whether it's fast enough for you

Speed here is subjective, so verify it against your own typing:

1. Install Albert and set a hotkey you can hit without looking.
2. Summon and type a short query (for example, the first letters of an app name) at your normal pace, then at a deliberately faster pace.
3. Watch for input lag — characters appearing behind your keystrokes is the clearest sign the launcher can't keep up.
4. Repeat with your typical plugins enabled, since that reflects real use better than a bare install.
5. Test action execution by launching an app or running a command and noting the delay after you confirm.

If results keep pace at your fastest typing and actions fire promptly, the launcher meets the 200+ KPM design target in practice. If you notice lag, disable plugins you don't use and retest — the plugin layer is the most likely source of slowdown.

Limits of the speed claim

The 200+ KPM figure describes the input rate Albert is engineered to handle; it is not a measured latency number, and the site does not publish benchmark timings. Actual responsiveness also depends on your hardware, the number of enabled plugins, and what those plugins query (local app indexes are typically faster than plugins that hit external services). For most users the practical question is simply whether typing feels uninterrupted — and Albert's core design is aimed squarely at that.

Albert supports three extension paths: native C++/Qt plugins, embedded Python modules, and CGI-based extensions in any language. The right choice depends on whether you need deep system integration, fast iteration, or language freedom. Albert's plugin-based architecture is explicitly designed so plugins can serve as either frontends or functional extensions, and the project ships APIs it describes as simple and easy to learn, plus utilities intended to accomplish common tasks with minimal code.

Choose your extension route

A practical rule: start with Python if your extension is mostly logic and you want to iterate quickly; move to a native plugin if you need to shape Albert's interface or react at launcher speed; use CGI when the functionality already exists as a script or must be written in another language.

What "extension" means in Albert

Albert is a keyboard launcher written in C++/Qt, and its plugin system is the mechanism that lets it be either "your go-to app launcher or a full-blown system command palette." That framing matters for developers: an extension is not limited to adding search results. Plugins can create frontends (changing how Albert presents itself) or functional extensions (adding new actions and query handling). Decide which of the two you are building before choosing a route, because frontend work generally pushes you toward the native plugin API.

Start from the official developer surface

The project site is the entry point for API details, utilities, and contribution standards. The site states that Albert offers APIs "designed to be simple and easy to learn" and "a set of powerful utilities" to accomplish common tasks with minimal code — so the intended workflow is to lean on those utilities rather than reimplement plumbing.

A concrete way to begin, for example when you want a custom command that acts on the currently selected item:

1. Define the trigger. Decide what the user types or what context (selected file, clipboard, active window) your extension responds to.
2. Pick the route using the table above, based on whether you need UI control, speed, or another language.
3. Implement against the documented API, using Albert's provided utilities for common operations instead of writing them yourself.
4. Verify inside the launcher. Trigger your extension from Albert's query bar and confirm both the expected result and the behavior when nothing matches — the failure path is where most first extensions break.
5. Check it against the bundled plugin standards. Albert describes its included plugins as peer-reviewed, actively maintained, and free of duplicates or broken code; matching that bar is the practical target if you intend to distribute your extension.

Use the bundled plugins as reference implementations

Albert ships "a curated collection of peer-reviewed, actively maintained plugins," described as working out of the box with no searching, no duplicates, and no broken code. For a developer, these are the most reliable worked examples of the API in use: read a bundled plugin that resembles your goal — a simple query handler, or one that surfaces system information — before writing your own. This is faster than starting from a blank file, and it keeps your code aligned with the conventions the project actually maintains.

Common sticking points

• Choosing too heavy a route. Writing a native C++ plugin for logic that a Python module could handle adds build complexity for no benefit.
• Ignoring the frontend/functional distinction. If your goal is to change how results are displayed, a CGI script will not get you there; that is plugin-API territory.
• Skipping the utilities. The site emphasizes minimal code via provided utilities; hand-rolling common tasks tends to produce extensions that drift from project conventions.
• Not testing the empty-result case. A launcher extension is judged as much by what it does when it has nothing to offer as when it succeeds.

Bottom line

Extend Albert by picking the lightest route that meets your need: Python for logic, native plugins for UI and performance, CGI for language freedom or reuse. Build on the documented APIs and utilities, model your code on the maintained bundled plugins, and test the no-match path before shipping.