Sitefinity CMS & .NET Core: The Future of Cross-Platform Development

Set up and start instantly. Code and get to market faster. Supercharge your frontend development. Join a journey to full .NET Core re-platforming.

Try now

.NET Core Code Samples

Foundation Course in .NET Core

Take your digital strategy to the next level with a DXP. And it all starts with Sitefinity.

Get Started

Sitefinity .NET Core Kickstarter Package

Build immersive, cross-platform solutions with Sitefinity and .NET Core.

DEVELOPER STARTER KIT

Tiered Architecture. Decoupled Presentation on .NET Core. API-driven Content Delivery

Modern WCMs are set up to distribute content and build experiences that take place on multiple platforms and devices, beyond just websites. The capabilities to send content to any digital format and frontend framework set winning WCMs apart.

Content editors need the tools to create, manage and reuse content from a single, central hub and distribute it across channels and touchpoints. Developers, on the other hand, need to break the inherent limitations of traditional WCMs and be able to leverage any frontend framework to deliver across platforms and devices.

A modern WCM fosters this sort of cross-team collaboration and provides the toolset for frontend-agnostic content management and delivery.

The presentation layer is handled by a stand-alone application, separate from the backend and content management, consuming data from a set of OData APIs. The Page Layout service, for example, is providing content to the .NET Core renderer but the beauty of it is it can work just as well with any other frontend technologies. The Page Layout service is now fully production-ready for a wealth of headless implementations, frontend flexibility and developer productivity.

Experience .NET Core and the full range of Sitefinity capabilities.
Take performance, scalability, security and productivity to the next level.

Developer Resources

Sitefinity and .NET Core

Don’t get trapped into legacy tech stacks. Code and deliver faster, across platforms and devices.

.NET Core

New .NET Core renderer and frontend development suite

API-driven
Optimal Performance with native MVC .Net Core
Cross-platform

Learn more

More Out-of-the-Box Widgets

Kickstart development for a stellar time to market. Layout Widgets and out-of-the-box Content Widgets

Content Block widget
Image widget
CTA widget

Learn more

Versatile Page Editor

ASP.NET Core and new page editing concepts in Sitefinity

WYSIWYG page editor
New Page Layout Management
Widget Selector
Page Templates

Learn more

APIs and Data Services

Decoupled via APIs. Extensible via REST.

Cross-platform development
Wealth of headless implementations
Marketer & content editor self-service

Learn more

Benefits

A Powerful, Future-proof Development Framework

Sitefinity was built for extensibility, integration and flexibility. The platform overdelivers in terms of performance, while modern DevOps practices and workflows make upgrades and collaboration a breeze. Sitefinity is a pleasure to work with and secure by design.

Technology Benefits

No OS lock. Deploy on Linux, MacOS, Windows
Frontend flexibility. Less code, simpler structure
Instant startup and faster development
Resource-efficient maintenance
Hosting flexibility
Quickly scalable

Architecture Benefits

Tiered architecture, separation of concerns
Content detached from administration
Customize the frontend without dealing with the backend
Extensibility with other rendering engines and IDE
Light on resources and maintenance
Resource-efficient scalability

Productivity Benefits

Shorter time to market
Streamlined upgrades
Tighter system security and superior reliability
Legacy frontend technology issues resolved
Stand-alone frontend application requires less resources to deploy and run
Faster client-side development

Frequently Asked Questions

Expand all

What are the benefits of separating content management from presentation?

An architecture built on separation of concerns has multiple positive effects on administration, development, hosting, deployment and scalability.

The content you create can be reused and easily delivered and maintained across multiple frontend consumers. Whenever content is updated, it’s ready to be consumed via APIs by any frontend framework you choose to employ. Content editors have a high level of flexibility and independence, meaning developers on the other hand are free to explore more and better ways to improve the user experience and leverage diverse frontend technologies.

The .NET Core renderer in Sitefinity 13, for example, is a stand-alone application that can be deployed and hosted anywhere. It can work on any OS that .NET Core supports and you can use any text editor. When developing new features and functionality, you work on the presentation layer of Sitefinity only, which lets you iterate at a higher speed.
Is Sitefinity .NET Core-ready?

The .NET Core Renderer started as a technical preview in Sitefinity 13.0 aiming to give early adopters a taste of the full .NET Core replatforming that's firmly on our roadmap. In upcoming releases, we will continue extending the functionality as we target a presentation layer fully relying on .NET Core as the technology to develop widgets, templates and scripts. The full frontend development suite.

In Sitefinity 13.1, the Page Layout API received a major performance boost through a newly implemented cache mechanism. The Page Layout API is the key service exposing content to the .NET Core renderer, alongside multiple other frontend frameworks as well. A number of out-of-the-box .NET Core widgets were also introduced in the 13.1 release as part of Sitefinity’s .NET Core roadmap: content block widget, image widget and CTA widget.
Widgets to ViewComponents? When do you plan full feature parity? What’s the Sitefinity Roadmap?
Plans to migrate existing pages and widgets are being prepared for the upcoming releases. There will be several migration models available to Sitefinity license holders.
- Guidelines for the migration of MVC widgets - migration of MVC views and business logic (manual migration of code)
- One-way migration of existing pages to the renderer and editor: full migration of legacy pages built on MVC and Webforms along with widgets and templates. Considering ways to automate the process.
Migration of existing .NET Core projects to the CMS. Since we have seamless integration with the .NET core pipeline, users will be enabled to migrate their MVC razor pages and controllers to the CMS pages. This would be an entirely manual process.
Can I use existing widgets alongside .NET Core?

Sitefinity constructs pages via the Page Editor with “drag and drop” support. Even users with little or no coding skills can easily build pages. Behind the scenes these widgets and their configurations are stored in the Sterility database as a meta model. The renderer can consume this model via REST services, parse it and construct a page for the specific set of widgets. It then renders the page in HTML and returns it to the end user.

These pages are based on templates coming from the Renderer. In the case of the .Net Core renderer, they are MVC Layout files in the file system. These layout files are available to choose from when creating a page. If a page is based on one of these layout files, the renderer will be able to render the page.

The standard approach to extending the Sitefinity frontend is to write custom widgets or configure/override the logic of the prebuilt ones. The corresponding elements for widgets in .Net Core are ViewComponents. Widgets that are available in the drag and drop editor correspond to the ViewComponents classes in the .Net Core Application.
I have a new project. Should I start implementing it with .NET Core or I can safely work with the old one?

The Sitefinity .NET Core Renderer is still in Community Technology Preview. If the two OOB widgets serve your needs, you are free to start developing with .NET Core. Although we plan to elaborate on it, we will not cease to support the standard .NET framework and the two-tier Sitefinity CMS architecture.