Cornerstone v8: The engineering rationale behind mohunky’s unified UI Platform
Posted by Rob Mayes today
Cornerstone has always been part of mohunky’s DNA. What began as a handful of quick start files slowly grew into a CSS layout framework, then a baseline set of Umbraco docTypes, then a UI component library, and eventually an entire modular web and application framework. Over the years it absorbed identity providers, eCommerce layers, encryption utilities, reporting systems, and a long tail of internal tools. It was powerful, but it was also sprawling.
As we built more Umbraco sites, more Blazor portals, more dashboards and internal tools, we noticed a pattern: the same UI ideas were being implemented again and again in slightly different ways. A button might exist as a Blazor component in an Umbraco site, a different Blazor component in a portal, a hand‑rolled version in a backoffice preview, and yet another version in a mobile app. Each one drifted over time. Each one had its own quirks. And every bug fix had to be applied in several places.
Cornerstone v8 is the moment we stepped back and said: enough. Instead of treating Umbraco, Blazor, and admin tools as separate worlds, we rebuilt Cornerstone as a unified, platform‑agnostic UI system. One design system. One component library. One renderer. One set of modules. One implementation used everywhere.
Why Cornerstone needed a rebuild
The biggest issue was maintenance. Every new project was an iteration of the previous one, not a clean baseline. A bug fixed on Project A might be fixed differently on Project B. A layout tweak in one portal wouldn’t match the same tweak in another. Over time, these inconsistencies compounded and made long‑term maintenance unnecessarily expensive.
The build pipeline was another pain point. Cornerstone v7 relied on Grunt and a collection of ageing bundling tools. It worked, but it wasn’t elegant, and it certainly wasn’t modern. The pipeline felt bolted‑on rather than integrated. Cornerstone v8 replaces all of that with a lightweight, native approach: CSS variables for design tokens, MSBuild for concatenation, and WebOptimizer for runtime minification and cache‑busting. No Node.js. No NPM. No dependency chain waiting to break.
And then there was the platform divide. Umbraco and Blazor were evolving in parallel, but not together. In v7, Umbraco blocks were Razor partials, Blazor components lived in separate projects, and portals had their own UI layer entirely. There was no shared component model. If you wanted a hero banner in Umbraco and a hero banner in a portal, you built it twice. If you wanted a block preview in the backoffice, you built a third version. That fragmentation was the catalyst for the v8 architecture.
What Cornerstone v8 changes
Cornerstone v8 introduces a strict, layered architecture that forces consistency. Everything is packaged as private NuGet packages. Everything is versioned in lock‑step. And everything - from CSS tokens to Blazor components to Umbraco blocks - is designed to be consumed by any application shell.
The design system lives in CoreAssets. The Blazor SSR component library lives in CoreUi. Umbraco integration lives in UmbracoBlocks. A single shared renderer (IBlazorRenderer) outputs HTML for both Umbraco and Blazor portals. And the application shells - Umbraco, AdminPortal, AppPortal - become thin hosts that simply consume the platform.
The result is a system where a component is written once and used everywhere. A button is the same button in an Umbraco site, a Blazor portal, a backoffice preview, and a client dashboard. A block is the same block in the CMS and in the live site. A layout change propagates across every project automatically.
Concrete improvements over Cornerstone v7
This is where the rebuild really earns its keep. A few examples:
1. The “Three Versions of Everything” problem is gone
In v7, a component like a Feature Tile existed as:
- a Razor partial for Umbraco
- a Blazor component for portals
- a hacked‑together HTML snippet for block previews
They looked similar, but they weren’t the same. Fixing spacing or accessibility meant touching three codebases.
In v8, the Feature Tile is a single Blazor SSR component in CoreUi.
Umbraco blocks simply adapt CMS data into its interface.
Portals use it directly.
The backoffice preview renders the exact same component via the shared renderer.
One component. One implementation. Zero drift.
2. The Build Pipeline is finally modern
v7’s Grunt pipeline was functional but brittle. Updating dependencies was painful. Reproducible builds were hit and miss. And the CSS architecture relied heavily on manual concatenation and global overrides.
v8 replaces all of that with:
- native CSS variables
- MSBuild‑driven concatenation
- WebOptimizer for runtime minification
- no Node.js, no NPM, no bundlers
It’s faster, cleaner, and dramatically more stable.
3. Umbraco Blocks are now properly typed and versioned
In v7, block definitions lived inside Umbraco itself. That meant:
- no version control
- no repeatable installs
- no way to guarantee consistency across environments
In v8, block definitions are JSON files inside UmbracoBlocks.
They’re versioned, packaged, and installed automatically.
A new project gets the exact same block library every time.
4. The Backoffice Preview is no longer a fake
v7 previews were static thumbnails or partial Razor renders that didn’t match the real front‑end.
v8 uses the actual Blazor component, rendered server‑side, with real CSS, real JS, and real data.
It’s the closest thing to WYSIWYG Umbraco has ever had.
5. Portals and Websites finally share a UI language
In v7, portals had their own UI layer. Websites had theirs. They looked similar, but they weren’t the same.
In v8, both use the same component library.
A table, a button, a card, a form - they all come from the same source.
The real outcome
Cornerstone v8 isn’t just a cleaner architecture. It’s a unification of everything mohunky builds. It gives us a single design system, a single component library, a single rendering pipeline, and a single set of backend modules - all versioned together, all delivered via NuGet, all consistent across every project.
It means we can build faster.
It means we can maintain less.
It means every client benefits from every improvement.
It means we can charge clients less for coprorate
And it means mohunky finally has what most agencies never achieve:
a genuinely unified UI platform across every stack we touch.
Get in touch to find out more about Cornerstone v8, how our unified Umbraco platform works, and how switching to mohunky could help streamline, modernise, and future-proof your business
Read more posts...
How Cornerstone is quietly transforming everything we build at mohunky
Posted by Natalie Mayes last month
Rethinking Web Complexity with Server-Rendered HTML
Posted by Rob Mayes earlier this year
Chat to us on WhatsApp
Scan, click or tap the QR code to start a WhatsApp chat.
Let's chat
If you have a specific project in mind, or you’re not sure what you need, please get in touch - we’d be happy to chat, even if it’s just for friendly advice!