Hyvä vs Luma: what changed when the licence went to zero
Hyvä’s free theme removes the licence obstacle, but the decisive difference is the front-end architecture and the cost of rebuilding a storefront around it.
The licence changed. The rebuild cost did not.
Hyvä Theme became free and open source on 10 November 2025. Before that, it was available under a one-time licence costing EUR 1,000. The change makes the entry point considerably easier to justify, particularly for Magento Open Source merchants evaluating a move from the default front end.
It does not make a migration cheap. Hyvä Checkout, Hyvä Commerce and Hyvä Enterprise remain separate paid products, so removing the theme licence does not remove every commercial component associated with the ecosystem.
The important distinction is between access to the theme and the work required to run a store on it. A Hyvä implementation is not a reskin of Luma. It replaces the front-end rendering, JavaScript and styling approach, then usually requires custom templates, compatibility work and a new test cycle.
That is why the licence was never usually the largest cost in the decision. The bill sits in development: rebuilding the storefront, adapting extensions and verifying behaviour after the rebuild.
What became free on 10 November 2025
The specific change applies to Hyvä Theme. It became free and open source rather than requiring the former one-time theme payment. Merchants using Magento Open Source can therefore assess Hyvä without treating the old EUR 1,000 theme licence as the first commitment.
That is different from saying that all Hyvä software is free. Checkout is a paid product, as are the Commerce and Enterprise offerings. A store choosing a paid Hyvä component still needs the relevant commercial licence, and its cost should appear in the project comparison.
There is also a transition point for existing customers. Holders of an old Hyvä Theme licence can put EUR 1,000 towards a Hyvä Commerce licence. That recognises the earlier payment without turning the previous theme licence into an entitlement to the paid products.
This distinction matters when comparing the total commitment of two projects. A Luma implementation can use the default Magento front end without a theme purchase, but heavily customised Luma work carries development and maintenance costs. A Hyvä implementation starts with a free theme but may carry a checkout licence, paid extension licences and a larger initial rebuild.
Neither starting point settles the question. The relevant comparison is the cost and burden of the resulting storefront over its working life.
Luma and Hyvä use different front-end foundations
Luma is the default Magento storefront theme. It is built on LESS, Knockout.js and RequireJS, with jQuery still familiar to many Magento 2 themes built around it. Blank is its parent theme, giving extensions and custom code a shared base to inherit from or override.
That architecture reflects the era in which the default storefront was assembled. Knockout handles client-side bindings, RequireJS loads JavaScript modules, LESS provides the preprocessor and theme inheritance system, and jQuery appears in a large amount of inherited Magento 2 front-end code.
For an established Magento 2 store, this can be an advantage. Customisations often extend an existing type, layout, template or JavaScript component rather than replacing the front end wholesale. Teams that know Knockout, RequireJS and Magento’s template conventions can maintain that code with relatively little retraining.
It can also become a constraint. A long-lived store may accumulate global JavaScript, overlapping Knockout components, jQuery selectors and LESS overrides that affect several catalogue pages. The immediate task may be a small change, but the release needs tests around module loading, bindings, responsive behaviour and interactions with third-party extensions.
Hyvä replaces that foundation. It uses Tailwind CSS rather than LESS and Alpine.js rather than Knockout and RequireJS. Tailwind moves most styling decisions into utility classes applied directly to markup. Alpine handles lightweight client-side behaviour close to the HTML rather than through a larger Knockout component structure.
For teams starting with a fresh template, this produces a cleaner base in some important respects. There is no Blank parent theme to inherit, and there is no need to reproduce Luma’s Knockout and RequireJS conventions. Styling can be more local to the component being changed, while Alpine covers interactions without requiring the same component architecture.
The comparison is not “old JavaScript against new JavaScript”. It is between two established ways of building and maintaining a Magento front end. Luma fits teams with substantial Luma experience and existing assets. Hyvä fits teams prepared to rebuild those assets around a different model.
What the architectural difference means day to day
| Area | Luma | Hyvä |
|---|---|---|
| Styling | LESS compilation, theme inheritance and shared stylesheet patterns | Tailwind utility classes, with styling applied in the markup |
| Client-side behaviour | Knockout.js components and bindings, usually within a Magento JavaScript component structure | Alpine.js behaviour close to the rendered markup |
| Module loading | RequireJS and the wider Magento JavaScript module system | A different front-end structure that does not use Luma’s Knockout and RequireJS stack |
| Existing assets | Often reusable when they extend standard Luma or Blank conventions | Usually require review and conversion rather than direct reuse |
| Team familiarity | Common among experienced Magento 2 front-end teams | Requires Tailwind and Alpine conventions plus Magento template knowledge |
Tailwind changes where styling lives
Moving from LESS to Tailwind is not simply changing the file extension. LESS supports nesting, variables, mixins and imports that produce organised stylesheets. Tailwind provides a constrained utility vocabulary, so a component’s styles tend to sit beside its markup instead.
That can make local changes easier to reason about. A developer working on one product card does not need to trace a distant selector through several imported stylesheets to understand which rule applies. It also reduces the need for bespoke naming systems when a new component is created.
The trade-off is a different kind of consistency. Tailwind’s defaults and spacing scale can encourage regular output, but the result still depends on disciplined markup and sensible component decisions. A large conversion does not automatically become tidy because the styling framework has changed.
Luma teams also gain something from their existing conventions. A Blank-based child theme, extension stylesheet and tested set of overrides form part of a documented ecosystem. That accumulated knowledge has value, particularly when the team is maintaining rather than rebuilding.
Alpine changes how interactive behaviour is organised
Knockout gives Magento developers a component and observable model for building interactive JavaScript. RequireJS controls how those components and their dependencies are loaded. This machinery is capable, but a mature Luma store can carry substantial custom JavaScript around it.
Alpine takes a smaller and more local approach. Behaviour is commonly declared in the markup with directives, which can suit straightforward interface interactions. For a new Hyvä build, it avoids carrying over a Knockout component tree that has little reason to exist in the new theme.
Existing behaviour is the issue. A Luma store may have custom product options, wish-list interactions, cart behaviour, configurators or promotional modules implemented with Knockout and jQuery. Those features cannot simply be placed on a Hyvä page. Their behaviour has to be understood, rebuilt and tested.
The same applies to extensions. An extension with little or no front-end code may work without material changes. An extension that depends on Luma templates, Knockout bindings, RequireJS modules or specific LESS selectors needs compatibility work.
Hyvä is a storefront rebuild
A Magento theme determines much more than colours, typography and imagery. It affects the structure of catalogue pages, search results, product detail pages, cart and checkout presentations, customer account areas, navigation and the JavaScript that connects them.
Moving to Hyvä therefore starts with a fresh front end. Standard Magento templates can provide the functional baseline, but the look and behaviour have to be implemented in Hyvä’s conventions. Custom layouts, widgets and content can also need rebuilding if they rely on Luma-specific template logic.
Search optimisation, accessibility, responsive behaviour and analytics cannot be treated as leftovers until the end. They need to be included in the new templates, then tested against real catalogue data and real interactions.
This is why a project can look inexpensive when described as a “theme change” and still produce a substantial quotation. The scope is closer to replacing the customer-facing application while retaining Magento’s catalogue and business capabilities underneath.
Extension compatibility is usually the largest variable
Compatibility work depends on what the extension does. A backend-only extension that leaves the storefront untouched is unlikely to create much front-end work. A product finder, colour swatch, custom options module, review system or subscription component may depend on standard Luma templates and Knockout components.
Before choosing Hyvä, each extension should be classified. The useful question is not whether it is generally “Hyvä compatible”, but whether its current implementation requires Luma-specific templates, JavaScript or styling for the stores being migrated.
Compatible alternatives may exist, but replacing an extension is not free. The replacement may have different features, different configuration requirements and a different impact on templates. Data and operational changes may be needed as well as front-end work.
Custom code deserves the same scrutiny. Search the theme for Knockout bindings, RequireJS dependencies, jQuery behaviour, custom widget calls, template overrides and LESS rules. The bigger the inherited custom layer, the more the migration becomes a reconstruction exercise.
Extension compatibility is often where the apparent cost difference disappears. A clean Luma store with several extensions that have Hyvä-compatible versions may be straightforward to assess. A heavily customised store may require more work than a new Hyvä build because old assumptions are embedded throughout the front end.
The licence was never the expensive part
The old EUR 1,000 one-time theme licence was a real hurdle, especially for smaller stores, but it was not the main cost of adopting Hyvä. Development, extension compatibility, content migration, QA and launch preparation are the material items.
That is not an argument against moving now that the theme is free. It is an argument for putting the theme licence in its proper place. The project should be approved because the new front end reduces the expected burden of maintaining the store, not because the entry fee has fallen to zero.
Paid Hyvä products also belong in the calculation. If the store will use Hyvä Checkout, Commerce or Enterprise, those licences remain separate from the free theme and should be priced before the decision is made.
The commercially honest comparison is therefore between the full cost of improving Luma and the full cost of adopting Hyvä. On one side sit a possible Luma redesign, extension upgrades and maintenance of accumulated front-end code. On the other sit the Hyvä theme, any required commercial products, a storefront rebuild and the work needed to make extensions compatible.
Which stores should move to Hyvä?
A store should consider moving when its Luma implementation has become difficult to change, its customisations are concentrated in a limited set of pages, the required extensions have credible Hyvä-compatible implementations, and the team can support a deliberate front-end rebuild.
The test is whether the team can name the front-end work. If the catalogue, product, cart and checkout templates can be rebuilt from Magento’s underlying behaviour without recreating a large custom platform, Hyvä is a reasonable candidate. The extension list should also be explicit, including which modules need replacement or compatibility work.
A merchant with a clean standard Luma catalogue and little bespoke JavaScript may gain a simpler maintenance model. A team comfortable with Tailwind and Alpine can work directly with markup and components instead of maintaining a mature Knockout and RequireJS layer.
Migration timing also matters. A Hyvä rebuild is easier to justify when the store already needs a visual refresh, a catalogue redesign or a replatforming of slow, tangled front-end code. Doing both jobs in one project can be sensible, provided the new architecture is not being used to conceal unresolved functional requirements.
Which stores should stay on Luma?
A store should keep Luma when the current implementation is stable, the team knows its architecture, important extensions depend directly on Luma front-end code, or there is no realistic budget for a storefront rebuild.
The strongest reason to stay is not simply that Luma is the default. It is that the existing front end may already represent substantial, working investment. Replacing stable templates, tested JavaScript and custom business behaviour can discard that asset and introduce new risk without creating a corresponding benefit.
Stores with complex customisations should ask whether the migration would improve the business or merely replace familiar code with unfamiliar code. A large catalogue does not automatically need Hyvä. Neither does a desire for faster development in the abstract.
Near-term constraints can outweigh theoretical benefits. A planned peak trading period, an unresolved checkout issue, a major catalogue change or a limited release window may make the sensible decision to retain Luma while addressing the highest-cost maintenance problems separately.
Decide by workload, not by the old licence
Hyvä’s move to free and open source has removed an awkward upfront barrier, and it has made serious evaluation easier for Magento Open Source merchants. The architectural trade-off remains: Luma and Blank offer an established extension and inheritance model, while Hyvä replaces LESS, Knockout and RequireJS with Tailwind, Alpine and a rebuilt storefront.
The question for each store is straightforward: does the new front end create less work to maintain than the current one? Inventory the templates, custom JavaScript and extensions; identify what must be rebuilt; include any paid Hyvä products; and compare that workload with the realistic cost of improving and continuing Luma.
If the result is a clean Hyvä implementation that removes years of front-end friction, the free theme makes the decision easier. If it is a large compatibility project with no clear reduction in complexity, keeping Luma is likely to be the better commercial decision.
Questions this page answers
- What became free on 10 November 2025?
- Hyvu00e4 Theme became free and open source rather than requiring the former one-time theme payment.
- Does the free Hyvu00e4 Theme mean all Hyvu00e4 software is free?
- No. Checkout, Commerce and Enterprise remain paid products requiring the relevant commercial licences.
- What can holders of an old Hyvu00e4 Theme licence do?
- They can put EUR 1,000 towards a Hyvu00e4 Commerce licence.
- Can a store use Luma without buying a theme?
- A Luma implementation can use the default Magento front end without a theme purchase, but heavily customised Luma work carries development and maintenance costs.