Glaze by Raycast

Glaze is Raycast’s AI-assisted desktop app builder for macOS. Instead of producing a hosted webpage, it generates an app project that lives on the user’s Mac, can run offline when its features do not require the network, opens in its own window and can integrate with macOS features such as global shortcuts, file associations, drag-and-drop, deep links, background work and native Swift components.¹²

The current download page shows **v0.13.0.0** and requires **macOS Tahoe on Apple Silicon**. Windows and Linux are described as future plans rather than current supported platforms.³¹

Glaze’s strongest product-level differentiator is that projects and app data are local by default. The current privacy manual says apps, app data, project files and agent chat history stay on the Mac rather than being silently synchronized to Glaze’s cloud.⁴

The generated source is also directly accessible. Glaze documents the editable project under `.glaze-sources` in its Application Support directory, with a renderer, backend/main process and supporting project files. Manual edits are visible to the agent on its next turn.⁵

That is materially different from an app builder where the user only owns a cloud representation and cannot inspect the generated implementation. It gives technical users an escape hatch for fine-grained changes and makes the output auditable at source level.

There is still ecosystem dependence. The current homepage says people receiving a shared Glaze app need Glaze installed and must be signed in, even though they do not need a paid subscription to run the app.¹ Publishing is through the Public Store, Team Store or an unlisted Glaze link.⁶ So “you own the code” is true according to the documentation, but ordinary Glaze distribution is not the same thing as producing a completely independent notarized Mac App Store product.

The community `glaze-coder` project reinforces this distinction: it can build and run Glaze source locally with outside agents, but publishing to the Glaze Store still requires a Glaze account.⁷

The current manual documents global keyboard shortcuts, file associations, bidirectional Finder drag-and-drop, custom URL schemes, browser/app hand-offs and native Swift additions.²

That matters because many AI app builders are optimized around database-backed web apps. Glaze instead targets personal utilities and internal tools that need to touch the desktop: quick capture, menu-bar utilities, file-processing tools, local dashboards or workflow helpers.

Native Swift support complicates the simplistic criticism that every Glaze app is merely a web page in a shell. The base project is still described as a renderer plus backend and the editable source structure is web-technology friendly, but the agent can add Swift for Apple frameworks, background work and live native data. Projects using native Swift require Xcode 16.3 or later.²⁵

Glaze’s main experience is Agent Chat. Users describe the app or change, choose a model and can use Plan mode before code is written. The agent can take attachments and connected-tool context, while an annotate workflow lets users point to specific UI elements rather than describe them abstractly.⁸

The combination of prompt-level building and source-level escape hatch is a meaningful strength. Non-coders can stay inside the conversation; developers can inspect or edit the generated project directly.⁵

Version history is tied to agent changes. Glaze notes that manual source edits are not automatically captured as versions, so users who hand-edit should create a subsequent agent checkpoint if they want the current state preserved in Glaze’s version history.⁵

The quality question remains open. There is no current-evidence study measuring first-pass success, regression frequency, bug-fixing accuracy, time-to-app or maintainability against Replit, Lovable, Claude Code, Codex or conventional development. The vendor’s examples establish capability, not comparative superiority.

A local app builder can be unusually powerful because its agent may run commands or access files. Glaze’s current approvals documentation says actions outside the project boundary trigger a permission request. Examples include reading or writing elsewhere on the Mac or executing a command that touches sensitive resources.⁹

The request shows the reason and, where applicable, the path or command. Approval is one-time for that specific action; granting one request does not create open-ended permission for future sensitive actions.⁹

Plan mode adds a second control layer for larger changes: the agent can present a plan and wait for explicit approval before switching into build mode.⁹

These are sensible controls for an agent that can modify local software. They do not eliminate risk—users can still approve a harmful command—but they are stronger than an architecture that silently gives the coding agent unrestricted filesystem access.

The current Agent Chat manual describes Glaze Fast as the leaner, lower-credit option available on every plan, while Glaze Smart is the fuller workflow for harder builds and is included with Pro.⁸

The beta Bring Your Own Agent path can use an existing, locally authenticated Claude Code subscription. Glaze says it does not read or store Claude credentials; it uses the sign-in already present on the Mac.¹⁰

Every app starts private. Public Store publishing is available on Free, while Pro adds unlisted distribution.¹¹⁶

Remixing adds a community-development layer. Current documentation allows eligible Store apps to be copied into a new editable project or used as reference material. For safety, Glaze strips agent-instruction files before letting a reference app’s source influence the build agent.¹²

The current pricing page explicitly lists “Disable remixing of your apps” as a Pro feature.¹¹ The Remix manual still contains older Team Pro terminology, another reason to treat plan labels in the manual cautiously until the documentation catches up.¹²

Glaze AI lets generated apps add text generation, streaming, image understanding and image generation without the author shipping a model API key.¹³

The first time an app wants Glaze AI access, Glaze presents a platform-controlled permission prompt. Access is granted per app and can later be reviewed or revoked. The Store labels apps that use Glaze AI.¹³

A notable economic design is that the **end user’s** Glaze credits pay for Glaze AI usage, with a daily cap; the app author does not automatically absorb inference cost for every user.¹³

That makes public AI-powered utilities more economically feasible for hobbyist authors, but it also means “free app” does not necessarily mean free ongoing AI usage for the installer.

Authors can instead wire a custom external AI provider directly. Glaze warns that in that case the external provider’s own retention/training rules apply and that a desktop-shipped API key should be treated as potentially recoverable.⁴

The current live Glaze pricing page is the controlling commercial source because the Glaze Manual itself tells readers to use that page for the latest prices and credit allowances.¹¹¹⁴

Free includes Glaze Fast, a one-time 50-credit launch welcome pack, credit top-ups, Public Store publishing and the ability to build using a connected Claude subscription or another external agent against the local source.¹¹

There is no recurring Glaze-credit allowance on Free. Once the welcome balance reaches zero, users can buy a top-up or build through their connected Claude subscription.¹¹

Pro currently costs **$10 per month** and adds Glaze Smart, **100 monthly Glaze credits**, top-ups without the platform fee, Creator Hub analytics, unlisted publishing and the ability to disable remixing.¹¹

Unused monthly Pro credits roll into the next billing month and remain valid for two months from grant. Purchased top-up credits remain valid for three months.¹¹¹⁵

The live pricing page currently says Team is **free during the Beta**. It provides a private Team Store, teammate invitations and private distribution, while each member builds using their own Free or Pro subscription.¹¹

During the beta, runs through a connected Claude subscription do not spend Glaze credits and are unlimited on Glaze’s side, subject to Claude’s own usage limits.¹¹¹⁰ For users who already pay for Claude Code, that can make the $10 Pro subscription materially more attractive than a simple “100 credits” comparison suggests.

Credits used with Glaze’s own models are work-metered, not a flat per-message charge: a small edit costs less than a large build, and more capable models can cost more per turn.¹¹¹⁵ That is conceptually sensible but makes effective cost per completed app hard to predict without hands-on workload data.

Earlier secondary pages that still show approximately $20–$35 paid tiers or 200-credit allowances are stale against the live August 27 pricing page and are excluded from current price facts.¹⁶¹⁷¹⁸

Glaze’s privacy documentation distinguishes local project state from AI processing clearly.⁴

Local app files, project data and chat history remain on the Mac. When the build agent needs model inference, Glaze says it sends the prompt, conversation context, app description, files the agent reads or edits, command output and attachments to the Glaze AI service/model providers. The whole project is not uploaded upfront; code reaches the provider as the agent opens it.⁴

Glaze says it does not use prompts or content to train or tune underlying models and that inputs are not retained once a response is generated, subject to specified exceptions including uploaded files needed for app operation, feedback/issue reports and short model-generated prompt summaries linked to the account for service improvement.⁴

For built apps using Glaze AI, the relevant input leaves the app to the model provider for that request. Glaze says it records metering information rather than the prompt/content itself and does not use the content for training.⁴

External service tokens such as GitHub, Linear or Slack connections are described as encrypted locally in macOS Keychain and revocable.⁴

The policy also highlights a subtle but important responsibility shift: when an author publishes an app, the author becomes responsible for what that app does with users’ data. Glaze’s privacy policy does not automatically govern every custom app’s behavior.⁴

That is the correct governance framing for user-generated software. A Glaze Store listing is not equivalent to Raycast certifying every author’s privacy design.

Publishing runs through automated checks. Glaze documents pre-upload checks for lockfiles and forbidden files such as `.env` or `.npmrc`, plus a review that can identify issues and block publication on critical findings.⁶

The same documentation is careful about its limits: automated review can scan for exposed keys, personal data and other risks, but it runs without human oversight and should be treated as a safety net rather than a guarantee.⁶

That caveat should be taken seriously. Glaze apps can access files, services and OS capabilities. The Store can improve baseline hygiene, but users should assess an installed app’s permissions and author like any other software download.

Glaze is especially compelling for Mac users who repeatedly wish they had a tiny utility tailored to a personal workflow: a file processor, menu-bar helper, local dashboard, quick capture tool or interface over existing APIs.

It also fits small teams that need internal software but do not want to commission a conventional application for every narrow process. Private team stores and integrations make the model especially natural when the tool sits on top of systems such as GitHub, Linear or Slack rather than replacing them.¹⁴

Developers can also use it as a rapid scaffold because the source is accessible and manually editable, though people who already live comfortably in Claude Code, Codex or another coding agent may find that Glaze’s biggest value is its runtime, Mac integration and distribution layer rather than the conversational coding itself.⁵⁷

It is a weaker fit for Windows/Linux users, public consumer-app developers who need independent App Store/DMG distribution, teams requiring mature third-party security certifications or buyers who need highly predictable build-cost accounting.