--- title: Blazor Tailwind Templates ---

Blazor Tailwind Templates

Rich Blazor templates with Tailwind CSS for building beautiful, responsive Apps

The feature-rich Blazor Tailwind templates are ideal for teams with strong C# skills building Line Of Business (LOB) applications who prefer utilizing Tailwind's modern utility-first CSS design system to create beautiful, instant-loading Blazor Apps. [ServiceStack.Blazor's Tailwind Components](/templates/blazor-components) work seamlessly across both [Blazor Server](https://learn.microsoft.com/en-us/aspnet/core/blazor/hosting-models?view=aspnetcore-6.0#blazor-server) and Blazor WASM hosting models, allowing you to choose the best approach for your use case.
## Getting Started Customize and Download a new Blazor Tailwind project with your preferred project name: Alternatively you can create & download a new Blazor Project with the [x dotnet tool](/dotnet-new): :::sh npx create-net blazor ProjectName :::
blazor.web-templates.io
## Blazor Rendering Modes ### Blazor Server Blazor Server has become the preferred platform for Interactive **Intranet** Apps which excels in **low-latency environments** to enable a best-in-class responsive end-user UX. It offers several compelling advantages: - A superior dev model and debugging experience - Improved live-reload and faster iterative dev cycles - Full access to .NET Server functionality - Better start times & UI responsiveness - Less complexity from unnecessary client project or pre-rendering solutions Although [the limitations](https://learn.microsoft.com/en-us/aspnet/core/blazor/hosting-models?view=aspnetcore-6.0#blazor-server) of its highly-coupled stateful server rendering session architecture does make it a poor fit for most high latency Internet sites. ### Blazor WASM with InteractiveAuto For Internet-facing applications, Blazor WASM with the `InteractiveAuto` render mode provides the best user experience. Our [blazor](https://github.com/NetCoreTemplates/blazor) template uses `InteractiveAuto` by default to provide a more responsive UI with static Server Side Rendering (SSR) for faster initial page loads and better SEO. ### Render Modes Blazor for .NET 10 has [four different rendering modes](https://learn.microsoft.com/en-us/aspnet/core/blazor/components/render-modes?view=aspnetcore-8.0#render-modes) you can take advantage of: - Static Server (static SSR) - Interactive Server - Interactive WebAssembly (WASM) - Interactive Auto For non-interactive pages, the static SSR mode is the fastest, as it renders the page on the server and sends the HTML to the client. However, when your page needs to be interactive, you need to use one of the interactive modes. Prior to .NET 10, there was a trade-off between the two available render modes (static server rendering wasn't yet available). The `Interactive Server` mode was faster to load, but the `Interactive WASM` mode was more responsive. The initial load times for `Interactive WASM` could be quite slow, as the entire application and all its dependencies needed to be downloaded before the page could render most of the content. > The initial load time for the `Interactive WASM` mode can be quite slow even for a minimal app Our templates previously worked around this limitation with a custom Pre-Rendering solution, as the wait times were too long for a good user experience. .NET 10's new `Interactive Auto` mode provides the best of both worlds as pre-rendering is now enabled by default. When the page is first loaded, it uses the `Interactive Server` mode, which is faster than `Interactive WASM` as it doesn't need to download WASM resources. So the user can start interacting with the page straight away, but with a slight delay for each of their interactions due to having to perform round-trips to the server for each interaction. In the background, the WASM resources are downloaded which can then be used to render the site on the client for subsequent visits. ## Using InteractiveAuto in your Blazor application In Blazor for .NET 10, render modes can be set on both a per-page and per-component basis. ```html @page "/counter" @rendermode InteractiveAuto ``` ```html ``` --- ## Universal Blazor Components A fantastic property of Blazor is its support for multiple hosting modes which allows the same components to run in the Browser with Blazor WASM or rendered on the Server with Blazor Server. But whilst Blazor is capable of it, this trait is typically conceded in most Apps with database access where it recommends using [EF Core directly in Blazor components](https://learn.microsoft.com/en-us/aspnet/core/blazor/blazor-server-ef-core?view=aspnetcore-7.0) - effectively prohibiting reuse in Blazor WASM should you ever want to utilize Blazor's preferred hosting model for hosting your Blazor App's on the Internet.
### Blazing Fast Networkless APIs Whilst better performing, having Blazor components access DB's directly encourages a more tightly-coupled and less reusable & testable architecture than the traditional well-defined API dev model used in client/server Mobile & Desktop Apps or Web SPA Apps like WASM. To achieve the best of both worlds, we've enabled support for utilizing the In Process [Service Gateway](/service-gateway) in Blazor Server Apps which lets you retain the traditional client/server dev model for invoking your Server APIs **In Process** - avoiding any serialization, HTTP networking or even Kestrel middleware overhead to invoke your APIs directly! This enables using the **exact same source code** to call APIs in Blazor Server and WASM which allows us to develop reusable Blazor Components to invoke the same Server APIs that serve Web, Mobile and Desktop Apps in Blazor Server Apps. Where instead of using HttpClient to invoke your APIs, they're invoked directly from a C# method which will preserve its StackTrace where you'll be able to track the API call down to the Blazor UI component calling it. ServiceStack's [Message-based API Design](/api-design) makes it possible for all API calls in ServiceStack.Blazor components and project templates to be routed through these 2 methods: ```csharp public interface IServiceGatewayAsync { Task SendAsync(object dto, CancellationToken ct=default); //... } public interface IServiceGatewayFormAsync { Task SendFormAsync(object dto, MultipartFormDataContent form, CancellationToken ct); } ``` ::: info The `SendFormAsync` API is a new method added to support multi-part API requests with File Uploads ::: Which allows the HTTP `JsonApiClient` and networkless `InProcessGateway` clients to be used interchangeably. By default Blazor Server Apps now use the InProcess Gateway but can be switched over to invoke APIs using the HTTP `JsonApiClient` with: ```csharp BlazorConfig.Set(new() { UseInProcessClient = false }); ``` Which changes all `Api*` methods in Blazor components and Pages inheriting ServiceStack.Blazor's [BlazorComponentBase](https://reference.servicestack.net/api/ServiceStack.Blazor/BlazorComponentBase) to use the registered `JsonApiClient` client. Other components can access both the InProcess Gateway or `JsonApiClient` by injecting the `IClientFactory` dependency into their components, e.g: ```csharp public class MyComponent : ComponentBase { [Inject] public IClientFactory? ClientFactory { get; set; } public IServiceGateway Gateway => ClientFactory!.GetGateway(); public JsonApiClient Client => ClientFactory!.GetClient(); } ``` This capability is what has made it possible for high-level "API-enabled" components like [AutoQuery Grids](https://blazor-gallery.jamstacks.net/grid) and [AutoForm](https://blazor-gallery.jamstacks.net/gallery/autoform) to support both Blazor Server and Blazor WASM utilizing the most efficient API client available to its platform. The Blazor Gallery websites themselves are also good demonstrations of being able to run **entire Web Apps** in both Blazor Server and WASM, with all development being done with Blazor Server to take advantage of its superior iterative dev model then a script is used to "export" all pages to an identical Blazor WASM project. --- ## ServiceStack.Blazor Components The [ServiceStack.Blazor Components](https://blazor-gallery.jamstacks.net) have been updated for .NET 10 and work with the new `InteractiveAuto` render mode. This means you can focus more on your application logic and less on the UI, as the components provide a high-productivity UI for common tasks such as CRUD operations. ### AutoQueryGrid The [AutoQueryGrid](https://blazor-gallery.servicestack.net/gallery/autoquerygrid) component provides a full-featured data grid that can be used to display and edit data from an AutoQuery service. This is ideal for creating custom admin pages for your application. By integrating your admin screens into your application, you can optimize the user experience for specific workflows and get a huge amount of reuse of your existing AutoQuery services. ```html ``` :::{.wideshot} ![](/img/pages/blazor/wasm/autoquerygrid.png) ::: For [BlazorDiffusion](https://github.com/NetCoreApps/BlazorDiffusionAuto), our StableDiffusion example application, we used the AutoQueryGrid to create a custom admin page for managing the modifiers in the application. This is the simplest and fastest use of the AutoQueryGrid component, but it can also be heavily customized for lots of different use cases. In [BlazorDiffusion](https://github.com/NetCoreApps/BlazorDiffusionAuto) we customize the grid to enable easy navigation contextually between separate customized admin screens for each Creative, linking to related table data. :::{.wideshot} ![](/img/pages/blazor/wasm/blazordiffusion-creatives.png) ::: ```html ``` In the above example, we use the `ConfigureQuery` parameter to customize the query used by the AutoQueryGrid when displaying values. This is ideal if you want to filter the data for specific workflows, for example, only showing the data that is relevant to the current user. We combine this with a `Tabs` component to provide a navigation bar for the user to switch between the different filters on the same AutoQueryGrid. ```html ``` :::{.shadow .max-w-screen-sm} ![](/img/pages/blazor/wasm/blazordiffusion-tab.png) :::

:::{.shadow .max-w-screen-sm} ![](/img/pages/blazor/wasm/blazordiffusion-tab1.png) ::: We also use the `EditForm` parameter to customize the edit form for the AutoQueryGrid, so the workflow for editing a Creative is optimized using your own completely custom UI. ```html ``` ### Running on both Server vs Client When using the `InteractiveAuto` mode, first visits will be running on the server, so your pages and components need to be available to both projects, as well as have any required dependencies registered in both projects `Program.cs` files. By placing your shared pages and components in a shared project like the `.Client` project in the `blazor-wasm` template, you can easily share them between the two projects. Look for any of your pages or components that use the `@injects` directive, as these will need to be registered in both projects. ::: info Avoid sharing sensitive information via dependency injection, as this will be available to the client at runtime which will be able to be decompiled and inspected. ::: ### Source code and live demo The source code for the upgraded `BlazorDiffusionAuto` application is [available on GitHub](https://github.com/NetCoreApps/BlazorDiffusionAuto) and you can view a live demo of the application at [auto.blazordiffusion.com](https://auto.blazordiffusion.com). ### Conclusion The new `InteractiveAuto` mode in Blazor for .NET 10 provides the best of both worlds for Blazor applications. A built in pre-rendering solution means that you can have a fast initial load time, but still have a responsive UI for subsequent visits. And since the ServiceStack.Blazor components have been updated for .NET 10, you can take advantage of the high-productivity UI components to quickly create customizable and professional-looking admin pages in a Blazor application. ---

Blazor Tailwind

### Blazor Tailwind Components [Tailwind](https://tailwindcss.com) has quickly become the best modern CSS framework we've used to create scalable, [mobile-first responsive](https://tailwindcss.com/#mobile-first) websites built upon a beautiful expert-crafted constraint-based [Design System](https://tailwindcss.com/#constraint-based) that enabled effortless reuse of a growing suite of [Free Community](https://tailwindcomponents.com) and professionally-designed [Tailwind UI Component Libraries](https://tailwindui.com) which has proven invaluable in quickly creating beautiful websites & docs that have benefited all our new modern jamstacks.net templates. [![](/img/pages/blazor/tailwindui.png)](https://tailwindui.com) ### ServiceStack.Blazor Components Many of Tailwind UI's popular components are encapsulated in ServiceStack.Blazor's righ high-level tailwind components to enable the rapid development of CRUD UIs in Blazor Server and WASM Apps:
[![](/img/pages/blazor/gallery-splash.png)](https://blazor-gallery.servicestack.net) ServiceStack.Blazor Components support both hosting models which sees Blazor Gallery running on both **Blazor Server** and **WASM**:
Blazor Server
Blazor WASM
For a closer look at ServiceStack.Blazor Components in action, download & run them to see how good they'll run in your Environment:
NetCoreApps/BlazorGallery NetCoreApps/BlazorGalleryWasm Vue Component Gallery

Creating Beautiful Blazor Apps with Tailwind

Preview the highly productive development model of the new Blazor Tailwind template showing how easy it is to utilize beautifully designed components

Blazor Components

Rich, themable UI Component Library with declarative contextual Validation

To maximize productivity the template utilizes the **ServiceStack.Blazor** library containing integrated functionality for Blazor including an optimal JSON API HttpClient Factory, API-enabled base components and a rich library of Tailwind & Bootstrap UI Input components with integrated contextual validation support of ServiceStack's [structured Error responses](/error-handling) heavily utilized throughout each project template. ### Blazor Tailwind UI Components The Built-in UI Components enable a clean & productive dev model, which as of this release include: | Component | Description | |-------------------|-----------------------------------------------------------------------------------| | `` | Text Input control for string properties | | `` | Date Input control for Date properties | | `` | Checkbox Input control for Boolean properties | | `` | Select Dropdown for properties with finite list of values like Enums | | `` | Text Input control for large strings | | `` | Dynamic component utilizing the appropriate above Input controls in Auto Forms | | `` | Displaying successful notification feedback | | `` | Displaying error summary message when no contextual field validation is available | | `` | Used with `FilesUploadFeature` and `UploadTo` attribute to upload files | The Tailwind & Bootstrap components share the same functionally equivalent base classes that can be easily swapped when switching CSS frameworks by updating its namespace in your App's `_Imports.razor`. ```csharp @using ServiceStack.Blazor.Components.Tailwind //@using ServiceStack.Blazor.Components.Bootstrap ``` #### Themable Should it be needed, their decoupled design also allows easy customization by running the included [README.ss](https://github.com/LegacyTemplates/blazor-wasm/blob/main/MyApp.Client/Shared/Components/README.ss) executable documentation to copy each controls **Razor** UI markup locally into your project, enabling easy customization of all UI input controls. ### Bookings CRUD Example To demonstrate ServiceStack's clean & highly productive Blazor dev model, we'll walk through implementing the [AutoQuery Bookings CRUD](/autoquery/crud-bookings) example in Blazor. Since we're using [AutoQuery CRUD](/autoquery/crud) we only need to define the Request DTO with the input fields we want the user to populate in our `Booking` RDBMS table in [Bookings.cs](https://github.com/NetCoreTemplates/blazor/blob/main/MyApp.ServiceModel/Bookings.cs): ```csharp [Tag("bookings"), Description("Create a new Booking")] [Route("/bookings", "POST")] [ValidateHasRole("Employee")] [AutoApply(Behavior.AuditCreate)] public class CreateBooking : ICreateDb, IReturn { [Description("Name this Booking is for"), ValidateNotEmpty] public string Name { get; set; } public RoomType RoomType { get; set; } [ValidateGreaterThan(0)] public int RoomNumber { get; set; } [ValidateGreaterThan(0)] public decimal Cost { get; set; } public DateTime BookingStartDate { get; set; } public DateTime? BookingEndDate { get; set; } [Input(Type = "textarea")] public string? Notes { get; set; } } ``` Where we make use of [Declarative Validation](/declarative-validation) attributes to define the custom validation rules for this API. ::: tip The `[Tag]`, `[Description]` and `[Input]` attributes are optional to markup how this API appears in ServiceStack's built-in [API Explorer](/api-explorer.html#details-tab) and [Locode UIs](/locode/declarative) ::: ### Blazor App Thanks to ServiceStack's [Recommended Project Structure](/physical-project-structure) no any additional classes are needed as we're able to bind UI Controls directly to our typed server `CreateBooking` Request DTO used to define the API in [BookingsCrud/Create.razor](https://github.com/LegacyTemplates/blazor-wasm/blob/main/MyApp.Client/Pages/BookingsCrud/Create.razor): ```csharp
New Booking
()) />
@code { [Parameter] public EventCallback done { get; set; } [Parameter] public string? @class { get; set; } CreateBooking request = new() { BookingStartDate = DateTime.UtcNow, }; // Hide Error Summary Messages for Visible Fields which displays contextual validation errors string[] VisibleFields => new[] { nameof(request.Name), nameof(request.RoomType), nameof(request.RoomNumber), nameof(request.BookingStartDate), nameof(request.BookingEndDate), nameof(request.Cost), nameof(request.Notes), }; ApiResult api = new(); async Task OnSubmit() { api = await ApiAsync(request); if (api.Succeeded) { await done.InvokeAsync(api.Response!); request = new(); } } async Task close() => await done.InvokeAsync(null); } ``` Calling ServiceStack APIs requires no additional code-gen or boilerplate where the populated Request DTO can be sent as-is using the [JsonApiClient Api methods](/csharp-client#high-level-api-and-apiasync-methods) which returns an encapsulated successful API or structured error response in its typed `ApiResult`. The UI validation binding uses Blazor's `` to propagate any `api.error` responses down to the child Input components. That's all there's to it, we use [Tailwind's CSS Grid classes](https://tailwindcss.com/docs/grid-template-columns) to define our UI layout which shows each control in its own row for mobile UIs or 2 fields per row in resolutions larger than the [Tailwind's sm: responsive breakpoint](https://tailwindcss.com/docs/responsive-design) to render our beautiful Bookings Form:
Which utilizes both client and server validation upon form submission, displaying UX friendly contextual errors under each field when they violate any server [declarative validation](/declarative-validation) or Client UI **required** rules:
## Optimal Development Workflow Utilizing Blazor WebAssembly (WASM) with a ServiceStack backend yields an optimal frictionless [API First development model](/api-first-development) where UIs can bind directly to Typed DTOs whilst benefiting from ServiceStack's [structured error handling](/validation) & rich contextual form validation binding. By utilizing ServiceStack's [decoupled project structure](/physical-project-structure), combined with Blazor enabling C# on the client, we're able to get 100% reuse of your APIs shared DTOs as-is to enable an end-to-end Typed API automatically free from any additional tooling or code-gen complexity. ## Api and ApiAsync methods .NET was originally conceived to use Exceptions for error control flow however there's been a tendency in modern languages & libraries to shun Exceptions and return errors as normal values, an approach we believe is a more flexible & ergonomic way to handle API responses. ### The ApiResult way The `Api(Request)` and `ApiAsync(Request)` APIs returns a typed `ApiResult` Value Result encapsulating either a Typed Response or a structured API Error populated in `ResponseStatus` allowing you to handle API responses programmatically without `try/catch` handling: The below example code to create a new Booking: ```csharp CreateBooking request = new(); ApiResult api = new(); async Task OnSubmit() { api = await Client.ApiAsync(request); if (api.Succeeded) { await done.InvokeAsync(api.Response!); request = new(); } } ``` Which despite its terseness handles both **success** and **error** API responses, **if successful** it invokes the `done()` callback notifying its parent of the new Booking API Response before resetting the Form's data model with a new Request DTO. Upon **failure** the error response is populated in `api.Error` which binds to the UI via Blazor's `` to propagate it to all its child components in order to show contextual validation errors next to their respective Input controls. ## JSON API Client The recommended way for configuring a Service Client to use in your Blazor WASM Apps is to use `AddBlazorApiClient()`, e.g: ```csharp builder.Services.AddBlazorApiClient(builder.Configuration["ApiBaseUrl"] ?? builder.HostEnvironment.BaseAddress); ``` Which registers a typed Http Client factory returning a recommended pre-configured `JsonApiClient` to communicate with your back-end ServiceStack APIs including support for CORS, required when hosting the decoupled UI on a different server (e.g. CDN) to your server. If you're deploying your Blazor WASM UI to a CDN you'll need to specify the URL for the server, otherwise if it's deployed together with your Server App you can use the Host's Base Address. ### Public Pages & Components To reduce boiler plate, your Blazor Pages & components can inherit the templates local [AppComponentBase.cs](https://github.com/LegacyTemplates/blazor-wasm/blob/main/MyApp.Client/AppComponentBase.cs) which inherits `BlazorComponentBase` that gets injected with the `IClientFactory` and provides convenient access to most common APIs: ```csharp public class BlazorComponentBase : ComponentBase, IHasJsonApiClient { [Inject] public IClientFactory? ClientFactory { get; set; } public IServiceGateway Gateway => ClientFactory!.GetGateway(); public JsonApiClient Client => ClientFactory!.GetClient(); public virtual Task> ApiAsync(IReturn request) => UseGateway ? Gateway.ManagedApiAsync(request) : Client.ManagedApiAsync(request); public virtual Task> ApiAsync(IReturnVoid request); /*...*/ public virtual Task SendAsync(IReturn request); public virtual Task ApiAsync(object request); public virtual Task> ApiFormAsync(object requestDto, MultipartFormDataContent request); } ``` ### Protected Pages & Components Pages and Components requiring Authentication should inherit from [AppAuthComponentBase](https://github.com/LegacyTemplates/blazor-wasm/blob/main/MyApp.Client/AppComponentBase.cs) instead which integrates with Blazor's Authentication Model to provide access to the currently authenticated user: ```csharp public abstract class AppAuthComponentBase : AppComponentBase { [CascadingParameter] protected Task? AuthenticationStateTask { get; set; } protected bool HasInit { get; set; } protected bool IsAuthenticated => User?.Identity?.IsAuthenticated ?? false; protected ClaimsPrincipal? User { get; set; } protected override async Task OnParametersSetAsync() { var state = await AuthenticationStateTask!; User = state.User; HasInit = true; } } ``` ## Benefits of Shared DTOs Typically with Web Apps, our client is using a different language to C#, so an equivalent request DTOs need to be generated for the client. ### TypeScript Example For example, TypeScript generated DTOs still give us typed end-to-end services with the help of tooling like [Add ServiceStack Reference](/add-servicestack-reference) ```csharp [Route("/hello/{Name}")] public class Hello : IReturn { public string Name { get; set; } } public class HelloResponse { public string Result { get; set; } } ``` Turns into: ```typescript // @Route("/hello/{Name}") export class Hello implements IReturn { public name: string; public constructor(init?: Partial) { (Object as any).assign(this, init); } public getTypeName() { return 'Hello'; } public getMethod() { return 'POST'; } public createResponse() { return new HelloResponse(); } } export class HelloResponse { public result: string; public responseStatus: ResponseStatus; public constructor(init?: Partial) { (Object as any).assign(this, init); } } ``` When Request or Response DTOs changes during development, the client DTOs need to be regenerated using a command like [`x csharp`](./add-servicestack-reference.md#simple-command-line-utilities). ### Blazor Example Developing your Blazor UI however, you just change your shared request/response DTO in the shared `ServiceModel` project, and both your client and server compile against the same request/response DTO classes. This eliminates the need for any additional step. In the `ServiceModel` project, we still have: ```csharp [Route("/hello/{Name}")] public class Hello : IReturn { public string Name { get; set; } } public class HelloResponse { public string Result { get; set; } } ``` Which the Blazor C# App can use directly in its **.razor** pages: ```csharp @code { Hello request = new() { Name = "Blazor" }; ApiResult api = new(); protected override async Task OnInitializedAsync() => await submit(); async Task submit() => api = await ApiAsync(request); } ``` ### FileUpload Control The File Upload UI component used in the [File Blazor Demo](/locode/files-blazor) has been extracted into a reusable Blazor component you can utilize in your own apps: ![](/img/pages/templates/fileupload-blazor-usage-example.png) It's a simple control that takes advantage of ServiceStack's declarative [Managed File Uploads](/locode/files-overview) support to effortlessly enable multiple file uploads that can be declaratively added to any Request DTO, which only requires setting 2 properties: | Property | Description | |------------------|----------------------------------------------------------------------------------------------------| | Request | Request DTO object instance populated with into to be sent to your endpoint | | FilePropertyName | The name of the property that is used to reference your file, used with the `[UploadTo]` attribute | #### Example usage Below is an AutoQuery CRUD API example that references an upload location defined when configuring the [FileUploadFeature Plugin](/locode/files-upload-filesystem.md): ```csharp public class CreateMyDtoWithFileUpload : ICreateDb, IReturn { [Input(Type="file"), UploadTo("fs")] public string FilePath { get; set; } public string OtherData { get; set; } } public class QueryFileUpload : QueryDb {} public class MyDtoWithFileUpload { [AutoIncrement] public int Id { get; set; } public string FilePath { get; set; } public string OtherData { get; set; } } ``` When calling this API, the Managed File Uploads feature will upload the HTTP File Upload included in the API request to the configured **fs** upload location and populate the uploaded path to the `FilePath` Request DTO property. The Blazor `FileUpload` Control handles the [C# File Upload API Request](/locode/files.html#uploading-files-from-c) by providing the Request DTO instance to send and the DTO property the File Upload should populate: ```html @page "/file-upload"

FileUploadPage

@code { // Any additional values should be populated // on the request object before the upload starts. CreateMyDtoWithFileUpload request = new() { OtherData = "Test" }; } ``` ![](/img/pages/templates/fileupload-blazor-example.png) The `FilePropertyName` matches the property name that is annotated by the `UploadTo` attribute. The `Request` is the instance of the Request DTO. ### Existing Template Upgrade for 6.3 If you created a `blazor-tailwind` project using this template before the ServiceStack 6.4 release, you should run the following commands to upgrade your project to use components from `ServiceStack.Blazor` component library which should be run from your `.Client` project: ::: sh npx add-in -delete blazor-upgrade-clean ::: ::: sh npx add-in blazor-upgrade :::