macOS Alfred vs Raycast: Launcher Comparison

Introduction to macOS Launchers

For developers on macOS, efficiency is paramount. The native Spotlight search is adequate for basic file lookups, but power users require a tool that acts as a central hub for application launching, clipboard management, automation, and scripting. This is where third-party launchers come into play. In the macOS ecosystem, two tools dominate this space: Alfred, the long-standing veteran, and Raycast, the modern, developer-focused challenger.

The Contenders: Alfred vs Raycast

Alfred has been the go-to launcher for over a decade. It relies on a visual workflow builder and supports scripting in various languages (Bash, Python, AppleScript). Raycast, on the other hand, is a newer application built entirely in React and TypeScript. It offers a modern UI, built-in window management, and a robust API for creating extensions using standard web technologies.

Why Launchers Matter for Developers

As a developer, context switching is one of the biggest drains on productivity. Launchers mitigate this by keeping your hands on the keyboard and allowing you to execute complex actions without navigating through multiple GUI windows. Whether you need to convert a JSON payload, search documentation, manage Docker containers, or format a timestamp, a well-configured launcher can perform these tasks in milliseconds. Furthermore, the ability to write custom scripts means your launcher can integrate directly with your specific development environment and CI/CD pipelines.

Core Features Comparison

Search and Navigation

Both tools excel at fuzzy searching applications and files. Raycast offers a slightly more modern fuzzy-matching algorithm out of the box, while Alfred allows deep customization of search scopes and file types. Both allow you to navigate the file system directly from the launcher bar.

Clipboard History and Snippets

Developers constantly copy and paste code snippets, API keys, and URLs. Both Alfred and Raycast feature excellent clipboard history managers. Raycast includes this natively for free, whereas Alfred requires the paid Powerpack. Both support permanent snippets, allowing you to type a short keyword (e.g., !email) to expand into a full block of text or code.

Window Management

Raycast includes a highly capable window management suite out of the box, allowing you to snap windows to halves, quarters, or maximize them using keyboard shortcuts. Alfred does not include native window management; users must rely on third-party workflows or separate applications like Rectangle to achieve similar functionality.

Extensibility: Workflows vs Extensions

The true power of these launchers lies in their extensibility. This is where the philosophical differences between Alfred and Raycast become most apparent.

Alfred Workflows

Alfred uses a visual drag-and-drop interface to build workflows. You connect inputs (hotkeys, keywords, file actions) to outputs (notifications, opening apps, copying to clipboard). For complex logic, you insert "Script Filter" nodes where you can write scripts in Bash, Python, or Node.js. The output must be formatted as a specific JSON structure that Alfred can render as a list.

Raycast Extensions

Raycast extensions are built using TypeScript and React. You write standard React components that render inside the Raycast window. This approach is highly familiar to modern web developers. Raycast provides a CLI tool to scaffold, build, and publish extensions to their community store.

Practical Example: Building a Custom Command

To illustrate the developer experience, let's look at how to build a simple command that fetches and displays a list of GitHub repositories. We will build this in both Raycast and Alfred.

Creating a Raycast Extension (TypeScript)

In Raycast, you use the raycast CLI to generate a new extension. You then write a React component using the @raycast/api library. The UI is declarative and handles loading and empty states gracefully.

import { List, Action, ActionPanel, Icon, usePromise } from "@raycast/api";
import { useState } from "react";

// Mock fetch function for demonstration
async function fetchRepos(query: string) {
  return [
    { id: 1, name: "raycast-extensions", stars: 1200 },
    { id: 2, name: "alfred-workflows", stars: 950 }
  ].filter(repo => repo.name.includes(query));
}

export default function Command() {
  const [searchText, setSearchText] = useState("");
  const { isLoading, data } = usePromise(() => fetchRepos(searchText), {
    execute: searchText.length > 0
  });

  return (
    <List isLoading={isLoading} onSearchTextChange={setSearchText}>
      {data?.map((repo) => (
        <List.Item
          key={repo.id}
          title={repo.name}
          subtitle={`Stars: ${repo.stars}`}
          icon={Icon.Star}
          actions={
            <ActionPanel>
              <Action.OpenInBrowser url={`https://github.com/example/${repo.name}`} />
            </ActionPanel>
          }
        />
      ))}
    </List>
  );
}

Creating an Alfred Workflow (Bash Script)

In Alfred, you would create a new workflow, add a "Script Filter" node, and set the language to Bash. Alfred passes the user's query as an environment variable or argument, and your script must output a JSON string formatted to Alfred's specifications.

#!/bin/bash

# Alfred passes the query as an argument
query="$1"

# In a real scenario, you would use curl to hit the GitHub API
# For demonstration, we output static JSON filtered by the query

cat <<EOF
{
  "items": [
    {
      "uid": "1",
      "title": "raycast-extensions",
      "subtitle": "Stars: 1200",
      "arg": "https://github.com/example/raycast-extensions",
      "valid": true
    },
    {
      "uid": "2",
      "title": "alfred-workflows",
      "subtitle": "Stars: 950",
      "arg": "https://github.com/example/alfred-workflows",
      "valid": true
    }
  ]
}
EOF

Notice the difference: Raycast handles the UI rendering and state management via React, while Alfred requires you to manually construct the JSON payload. Both approaches are powerful, but Raycast's method offers better type safety and a richer UI toolkit.

Best Practices for Launcher Productivity

Memorize Core Hotkeys: Force yourself to use the launcher for everything. Uninstall apps from your Dock to break the habit of clicking.
Master Snippets: Create snippets for your most frequently used code blocks, email addresses, and terminal commands. Use a distinct prefix (like a semicolon or exclamation mark) to trigger them without interfering with normal typing.
Organize Extensions: If you install dozens of extensions or workflows, use aliases or hotkeys to group them by context (e.g., a dedicated hotkey for database tools).
Version Control Your Config: Both Alfred and Raycast store their configurations locally. Sync your configuration files to a private Git repository so you can quickly restore your setup on a new machine.
Leverage Universal Actions: Both tools allow you to take action on selected text or files. Select a JSON string, hit your launcher hotkey, and format it instantly.

Conclusion

Choosing between Alfred and Raycast ultimately comes down to your development style and preferences. Alfred remains a robust, highly optimized tool with a massive backlog of community workflows, making it ideal for developers who prefer visual scripting or writing quick Bash/Python scripts. Raycast, however, is the clear winner for modern web developers. Its React/TypeScript API, native window management, and sleek, frequently updated UI make it feel like a natural extension of a modern development workflow. Both tools will dramatically increase your productivity, but Raycast's developer-first approach makes it the most compelling choice for new users setting up their macOS environment today.