Skip to content

Free Shopify Polaris playground

Polaris UI builder
for Shopify apps.

Drag and drop Shopify's real Polaris web components, start from App Home templates, and preview on desktop and mobile. Then export React JSX or HTML and paste it into your Shopify app.

Free and open source. No signup. App Home, checkout and customer accounts.

PlayPolaris visual builder with the Polaris component palette, an app overview screen, and a live property inspector
Drag a Polaris component into place and watch your Shopify admin screen take shape.Actual builder. Example project.

Made for
Shopify app developers.

Polaris web components
v2 + v1
React JSX & HTML
Typed export
WebMCP ready
Bring your AI agent
Open source
Free under MIT

The Polaris playground

Every Polaris component,
live in your browser.

All 62 Polaris web components in one visual Shopify app builder, with validation that explains itself and starter templates for common admin pages.

Real Polaris web components

Build with Shopify's actual Polaris runtime, not lookalikes. Start on Polaris 2.0, the new admin design, switch to v1 at any time, and interact with your screen as you go.

Shopify CDN runtime · 2.0 and v1

Polaris nesting and slot validation

Catch invalid nesting, misplaced slots, bad property values and accessibility gaps while you build. When a drop isn't allowed, the checker says why.

Live validation · Clear explanations

Shopify app UI templates and drag and drop

Start from a home, index, details, settings or empty-state template. Drag from the component palette, reorder layers, or add components in place.

5 starter templates · Drag and drop

Responsive preview for desktop, tablet and mobile

Switch the canvas between viewport sizes and check how your Shopify admin layout adapts before it reaches your codebase.

Desktop · Tablet · Mobile

Reusable saved components

Save any section you built as your own component. Drop a copy into any page, then adapt it without changing the original.

Save once · Reuse anywhere

Undo, redo and local autosave

Experiment freely. Duplicate pages to explore a direction, undo what didn't work, and come back to work saved in your browser.

Autosave in IndexedDB · Undo and redo

How it works

From Polaris template to exported code in three steps.

Open the Polaris builder
  1. 01

    Start from a template

    Pick a blank page or a Shopify App Home template: home, index, details, settings or empty state.

  2. 02

    Build and validate

    Drag in Polaris components, edit their properties in the inspector, and fix anything the checker flags.

  3. 03

    Export React JSX or HTML

    Download typed React JSX or plain HTML and paste it into your Shopify app.

Polaris React and HTML export

Export clean Polaris
React JSX or HTML.

Your layout becomes the same s-* markup Shopify documents for App Home. Copy one screen, download a full HTML document with the Polaris script tag, or bring typed React JSX into your app.

  • React JSX or TSX typed with @shopify/polaris-types
  • One page or your whole project as a ZIP
  • Optional Polaris and App Bridge script tags
Build it. Take it with you.
overview.html
<s-page heading="Your next big idea">
  <s-button slot="primary-action" variant="primary">
    Make it happen
  </s-button>
  <s-section heading="Made for your merchants">
    <s-paragraph>
      A little less setup. A lot more possibility.
    </s-paragraph>
  </s-section>
</s-page>

Checkout and customer accounts

Preview UI extensions where Shopify renders them.

Switch the builder to Checkout or Accounts. Shopify renders these components itself, so the preview uses stand-ins modeled on its default pages: close, not pixel-exact.

Checkout preview with a product offer extension rendered at the purchase.checkout.cart-line-list.render-after target, below the order summary line items

Checkout UI extensions

Pick a target. See it in checkout.

Build with the checkout component set, then choose where the extension renders: any documented target on the checkout and Thank you pages. Export it as a Preact module with its shopify.extension.toml entry.

Try it in the builder
Customer account order status preview with custom brand colors and heading font, and an extension rendered at the customer-account.order-status.block.render target

Customer accounts and branding

Order pages, in your brand.

Preview extensions on the order status, order index and profile pages. Change colors, fonts and corner radius and watch the page follow, then export the branding settings as an Admin API mutation.

Try it in the builder

Collaboration and AI agents

Build Shopify admin screens together, or with an AI agent.

Real-time collaboration

Share a link. Build together.

Invite someone into a shared copy of your workspace. Edit the same screens in real time, with undo for your own changes. Your personal workspace stays separate.

How shared sessions work
“Build a settings page for my app.”
01Read the component catalog
02Build with real Polaris
03Validate and export
Example workflow · Requires a WebMCP-compatible browser

WebMCP agent tools

Let your agent do the clicking.

With WebMCP, an AI agent can inspect components, build pages, check layouts, and export code alongside you. See its changes in the canvas, and undo them like your own.

Explore the agent tools

FAQ

Shopify Polaris
builder FAQ.

Have another question?
Find us on GitHub

What is PlayPolaris?

PlayPolaris is a free Shopify Polaris playground and UI builder. You arrange Shopify's real Polaris web components in a live preview, it checks Polaris nesting and slot rules as you go, and you export the screen as React JSX or HTML for your Shopify app.

Which Polaris components can I use?

All 62 Polaris web components for App Home: page, section, stack, grid and box for layout; text, number, money, date and color fields, selects, checkboxes and switches for forms; tables, badges, banners, modals, popovers, tooltips and more. The components page lists every one with a short example.

Is PlayPolaris a Storybook for Polaris?

Shopify's own Polaris Storybook documents each component on its own. PlayPolaris is a playground for whole pages: compose Polaris components into a Shopify admin screen, validate the result, and export it as React JSX or HTML.

Does it support Polaris 2.0?

Yes. Polaris 2.0 (polaris-2.js), which matches the new Shopify admin design, is the default. You can switch to Polaris web components v1 (polaris-1.js) at any time. The component catalog comes from Shopify's official @shopify/polaris-types packages.

Does it work with Polaris React?

PlayPolaris builds with Polaris web components, the s-* elements Shopify recommends for new App Home interfaces, and exports React JSX that uses them with types from @shopify/polaris-types. It doesn't generate code for the older @shopify/polaris React package. Shopify's migration guide covers moving from Polaris React to web components.

Are there Shopify app UI templates?

Yes. Start a page from a home, index, details, settings or empty-state template built with Polaris web components. Export any of them as HTML or React JSX.

Is it free, and do I need an account?

It's free, and there's no account or sign-up. Open the builder and start; your work is saved in your browser as you go.

Is PlayPolaris open source?

Yes. PlayPolaris is released under the MIT License. You can read the source code, report issues, and contribute on GitHub.

Where is my work stored?

In your browser's IndexedDB storage. Shared sessions relay edits to other people in the room without keeping a server copy. Clearing this site's data removes your local copies, so export pages you want to keep.

How do shared sessions work?

Start a shared session and send the link to a teammate. Anyone with that link can edit the shared copy, while your personal workspace stays separate. Each browser keeps a local copy; there is no permanent server copy. A new participant needs someone with a saved copy online to join. Export important work for backup.

Can I use the exported code in my Shopify app?

Yes. HTML export can include the Polaris and App Bridge script tags, and React export produces a component typed with @shopify/polaris-types. Both use the same s-* elements Shopify documents for App Home.

Does it check that my layout is valid?

Yes. It checks allowed parents, what each slot accepts, property values, duplicate ids and basic accessibility, and it refuses drops Polaris doesn't allow, with the reason.

Can AI agents use it?

Yes, in browsers that support WebMCP. The builder exposes tools for reading the component catalog, creating and editing pages, validating and exporting, so an agent can build screens alongside you.

Can I preview checkout and customer account UI extensions?

Yes. Switch the builder to Checkout or Accounts to build an extension, pick its extension target, and see it on a mock checkout, Thank you, order or profile page. You can edit the branding settings and export them, along with the extension code. Shopify doesn't publish a runtime for these components, so the preview uses stand-ins and is approximate.

Does it build a complete Shopify app or storefront?

PlayPolaris builds interface prototypes for Shopify App Home, not storefront themes or a complete app backend. Exported HTML and React JSX give you the UI structure. Connect your own app logic, data, authentication, and Shopify APIs in your project.

Is this an official Shopify product?

No. PlayPolaris is an independent tool. It loads Polaris from Shopify's CDN and follows Shopify's public documentation, but it isn't made or endorsed by Shopify.

Free. Open source. No signup.

Start building
your Shopify app UI.

Open the Polaris playground in one browser tab. Nothing to install.

Open the builder Free to use. Open source. Yours to explore.