Latest features & highlights

Background Jobs is our effortless solution for managing background jobs and scheduled tasks in any .NET 8 App, implemented in true ServiceStack fashion where it seamlessly integrates into existing ServiceStack Apps with a built-in Management UI to provide real-time monitoring, inspection and management of background jobs.

It packs all useful features we wanted in its initial V1 release, including:

• No infrastructure dependencies
  • Monthly archivable rolling Databases with full Job Execution History
• Execute existing APIs or Commands
• Schedule Reoccurring Tasks
• Serially execute jobs with named Workers
• Queue Jobs that Depends On successful completion of a parent Job
• Execute Callback on successful execution of Job
• Queue Jobs to Run After a specified Date
• Execute Jobs within the context of an Authenticated User
• Auto Retry and Timeout failed jobs on a default or per-job limit
• Cancellable Jobs
• Requeue Failed Jobs
• Maintain Status, Logs and Progress of Executing Jobs
• Execute transitive (i.e. non-durable) jobs

SQLite's low latency, high-performance and embeddable nature make it ideal for self-managing isolated appliance black-box functionality like Request Logging which offers up to 35% faster disk performance than standard file logging.

Rolling Monthly SQLite Databases​

SQLite is unique in its ability to create lightweight databases on-the-fly where Requests will be persisted into isolated Monthly databases which can be easily archived into managed file storage instead of a singular growing database.

SQLite Request Logs also make it easier to generate monthly aggregate reports that provide key insights into the usage of your App.

AutoQuery Admin Logging UI​

As SQLite Requests Logs also makes it efficiently possible to sort and filter through logs, the Admin Logging UI has been upgraded to using a fully queryable AutoQueryGrid when using SqliteRequestLogger

Ever since adding support for Litestream in ServiceStack project's templates GitHub Action Deployments we've been using SQLite as the backend for our latest new .NET Apps as it's the most cost-effective option that frees us from needing to use cloud managed databases and by extension expensive major cloud providers instead of the better value commodity cloud providers.

SQLite is a highly-performant DB that can handle a large number of concurrent read operations and 35% faster filesystem performance for write operations with next to no latency that's often faster than other RDBMS's courtesy of its proximity to the running application which gives it unique advantages over traditional client/server RDBMS's where it's not susceptible to the N+1 Queries problem and is also able to execute your custom C# Logic inside SQL Queries using Application SQL Functions.

With litestream.io taking care of real-time replication to managed storage we just need to workaround SQLite's single concurrent writer to unlock the value, performance and unique features of SQLite in our Apps which we cover in this release with integrated support for Database Locks and Sync Commands.

API Keys are a simple and effective way to authorize access to your APIs, which are typically used for machine-to-machine communication, where a client application needs to access an API without user intervention. API Keys are often used to control access to specific resources or features in your API, providing a simple way to manage access control.

Redesigning API Keys​

Building on our experience with API Keys in previous versions of ServiceStack, we've taken the opportunity to redesign how API Keys work to provide a more flexible and powerful way to manage access control for your APIs.

Given the primary use-case for API Keys is for machine-to-machine communication where the client isn't a User, nor do they want systems using their API Keys to have access to their User Account, we've changed how API Keys work in .NET 8.

How code-bases are structured is largely a matter of developer preference, however we believe we've also been able to add value in this area with the new appealing managed Commands Feature.

When to restructure​

Times when you may want to consider moving logic out of your Service include:

• Code Reuse: Make it easier to reuse your Service logic in other Services
• Complexity: Break down complex logic into smaller more manageable pieces
• Testability: Make it easier to test your Logic in isolation
• Observability: Make it easier to log and monitor
• Robustness: Make it easier to handle, retry and recover from errors
• Flexibility: Make it easier to run in parallel or in a different managed thread

We'll look at how the new Commands Feature can help in these areas.

With ServiceStack now fully integrated with ASP.NET Identity Auth, our latest .NET 8 Tailwind Templates offer a full-featured Auth Configuration complete with User Registration, Login, Password Recovery, Two Factory Auth, and more.

Whilst great for Web Applications that need it, it neglects the class of Apps which don't need User Auth and the additional complexity it brings inc. Identity and Password Management, EF Migrations, Token Expirations, OAuth Integrations, etc.

For these stand-alone Apps, Microservices and Docker Appliances that would still like to restrict Access to their APIs but don't need the complexity of ASP .NET Core's Authentication machinery, a simpler Auth Story would be preferred.

With the introduction of API Keys in this release we're able to provide a simpler Auth Story for .NET 8 Microservices that's easy for Admin Users to manage and control which trusted clients and B2B Integrations can access their functionality.

A consequence of RedHat Enterprise Linux 9's hardened system-wide cryptographic policies is that it's incompatible with ServiceStack's current licensing which uses RSA encryption and SHA1 hashing algorithm to validate license keys.

Unfortunately this makes it no longer possible to use License Keys to run unrestricted ServiceStack Apps on default installs of RHEL 9 or any of its variants.

Generate License Key for RHEL 9+​

Starting from ServiceStack v8.3+ Customers can regenerate a new License Key with a stronger SHA512 Hash Algorithm that's compatible with RHEL 9's default hardened cryptography policy by visiting:

With ServiceStack now fully integrated with .NET 8, our focus has shifted from providing platform-agnostic solutions that supports all ServiceStack's .NET Framework and .NET hosts to building on the new capabilities of .NET 8 by enhancing ASP .NET Core's built-in features and templates with ServiceStack's high-productivity features.

New Vue SPA Template​

The latest Vue SPA template is a good example of this, building on and enhancing the built-in ASP.NET Core Vue SPA template with many high-productivity features:

• ASP.NET Core Identity Auth Integration
• End-to-end Typed TypeScript APIs
• Beautiful Tailwind CSS with Dark Mode
• Universal Vite Press Plugin Markdown features
• Highly Productive Vue Component Library
• Effortless CRUD and Admin UIs with AutoQueryGrid

The ASP.NET Core Vite React SPA Template has also been upgraded and enhanced with many high-productivity features including:

• ASP.NET Core Identity Auth Integration
• End-to-end Typed TypeScript APIs
• Beautiful Tailwind CSS with Dark Mode
• Universal Vite Press Plugin Markdown features
• Integration with shadcn/ui Tailwind React components
• Native MDX Markdown integration
• React Router and conventional file system based routing
• Tailwind Validation bound Input Form Components

The last few years of neglect of Xamarin has removed itself from consideration as a viable development option for creating native Mobile and Desktop Apps.

Fortunately JetBrains has stepped in to fill the void with its Compose Multiplatform UI Framework offering a modern declarative alternative reactive for creating native Mobile, Desktop & Web Apps that can also leverage Kotlin ServiceStack Reference for its end-to-end typed APIs.

We'll look at the latest Compose Multiplatform v1.6 Release and use it to build a cross-platform Desktop App integrated with a .NET API backend which can both be developed from the same JetBrains Fleet IDE.

The Vite Press Plugin is an alternative to VitePress for adding Markdown features to existing Vite Vue or React projects. It's a non-intrusive plugin for Vue and React Vite apps that want to add markdown powered content features without needing to adopt an opinionated framework for their entire App.

Universal Markdown Features​

A goal for vite-press-plugin is to implement a suite of universal markdown-powered features that can be reused across Vue, React and .NET Razor and Blazor projects, allowing you to incorporate same set of markdown feature folders to power markdown content features across a range of websites built with different technologies.

Vite Apps with vite-press-plugin​

The vite-press-plugin currently powers the markdown features in the static Vite Vue and React templates which are ideal for creating static websites, blogs, documentation and marketing websites that can be hosted FREE on GitHub Pages CDN

We're happy to announce the latest ServiceStack v8.1 release supports deep integration with ASP.NET Core's standardized features for execution of its APIs.

This reduces friction for integrating ServiceStack into existing .NET 8 Apps, encourages greater knowledge and reuse and simplifies .NET development as developers have fewer concepts to learn and technology implementations to configure and maintain that are now applied across their entire .NET App.

Better yet, this is enabled by default in all of ServiceStack's new Identity Auth .NET 8 templates which now embraces all these standard ASP.NET Core features:

• ASP.NET Core Identity Auth
• ASP.NET Core IOC
• Endpoint Routing
• System.Text.Json APIs
• Open API v3 and Swagger UI
• JWT Identity Auth

ServiceStack Endpoint Routing APIs now utilize System.Text.Json - the default high-performance async JSON serializer used in .NET Apps for serializing its JSON APIs.

Enhanced System.Text.Json​

ServiceStack uses a custom JsonSerializerOptions to improve compatibility with existing ServiceStack DTOs and ServiceStack's rich ecosystem of generic Add ServiceStack Reference Service Clients, which is configured to:

• Uses CamelCaseNamingPolicy for property names
• Supports Case Insensitive Properties
• Not serialize null properties
• Serializes TimeSpan and TimeOnly Data Types with XML Schema Time format
• Supports [DataContract] annotations
• Supports Custom Enum Serialization

Utilizing the same ASP.NET Core Endpoints that the rest of the ASP.NET Core App uses enables your ServiceStack APIs to integrate with your wider ASP.NET Core application, opening up more opportunities for reuse of your ServiceStack APIs.

This opens up the ability to use common third party tooling like the popular Swashbuckle package used to to enable OpenAPI v3 specification generation of ASP .NET Core APIs which now includes ServiceStack APIs, displayed along-side Minimal and Web APIs.

We've created the ServiceStack.AspNetCore.OpenApi package to make this integration as easy as possible, which incorporates additional information from your ServiceStack APIs into Swagger metadata.

The new Identity Auth Admin UI is an example of value-added features that can benefit all .NET Core App, that enables a built-in Admin UI that's only accessible to Admin Users for managing Identity Auth users at /admin-ui/users.

It's a highly customizable UI feature that includes standard features to lockout users, change user passwords and manage their roles as well as being flexible enough to support Custom ApplicationUser Identity Models including:

• Custom Search Results
• Custom Search Behavior
• Custom Sort Order
• Custom Editable Fields
• Custom User Creation and Validation
• Admin User Events to run custom logic

We're excited to welcome the next major release of ServiceStack v8, designed to take advantage of many advancements for in .NET's latest long-term release: .NET 8

All NuGet Packages include net8.0 builds​

All of ServiceStack's active NuGet packages now include .net8.0 target framework builds along with their dependencies on Microsoft's packages upgraded to use the latest 8.0.0 that were released with .NET 8.

All .NET Project Templates upgraded to .NET 8​

All Project Templates have been upgraded to use ServiceStack v8 and .NET 8, inc. built-in CI/CD GitHub Actions upgraded to use secure rootless Linux Docker containers built into .NET 8 which allow you to effortlessly deploy your containerized .NET 8 Apps with Docker and GitHub Registry via SSH to any Linux Server.

ServiceStack's new Blazor project template takes advantage of .NET 8 Blazor's new features that redefines modern Web Development in C# which sees our new templates adopting Blazor's familiar ASP.NET Core Identity and Entity Framework for its authentication, utilizes the modern Tailwind CSS framework for beautiful responsive design and adopts .NET's best-practice Docker Containerization support for its built-in GitHub Action Deployments - enabling a simple ready-made CI solution for deployment to any Linux Host via SSH and Docker compose.

New Blazor Vue Template​

The new Blazor Vue template is ideal for building fast, SEO-friendly 100% statically rendered Blazor Web Apps where all its dynamic functionally uses Vue.js to progressively enhance its static rendered content - eliminating Blazor's limitations of using static rendering to implement an entire App.

A significant change we've added to our new .NET 8 Project Templates is the adoption of the same ASP.NET Core Identity Authentication that's configured in Microsoft's default Projects templates.

ASP.NET Core Identity Auth now used in new Integrated Auth projects Going forward all new ServiceStack .NET Project Templates will adopt ASP.NET Identity Auth, which closely follows the same approach as the Microsoft Project Template it integrates ServiceStack with, e.g. the new .NET 8 Blazor and Blazor Vue project templates adopts the exact same Auth configuration as Microsoft's default Blazor Project Template configured with Individual Identity Auth, likewise with the Bootstrap and Tailwind styled MVC and Razor Pages templates.

ASP.NET Core Identity Auth Migration Guide​

Migrating from ServiceStack Auth to Identity Auth should be relatively straight-forward as ServiceStack uses a compatible Identity v2 password hashing format, which should let you migrate your users to Identity Auth without them noticing.

To help with any migrations we've published an Identity Auth Migration Guide we've used to convert existing ServiceStack Auth Apps to use Identity Auth.

We're happy to announce the 11th Add ServiceStack Reference language to enjoy end-to-end typed support for calling .NET APIs - PHP!

PHP is one of the worlds most popular programming languages thanks to its ease of use, flexibility and fast development experience which sees it excels as a popular language for web development and for development of popular CMS products like WordPress, Drupal and Joomla.

First class development experience​

To maximize the experience for calling ServiceStack APIs within these environments ServiceStack now supports PHP as a 1st class Add ServiceStack Reference supported language which gives PHP developers an end-to-end typed API for consuming ServiceStack APIs, complete with IDE integration in PhpStorm as well as built-in support in x dotnet tool to generate Typed and annotated PHP DTOs for a remote ServiceStack instance from a single command-line.

ServiceStack.AI covers a Free suite implementation-agnostic abstractions for different AI and GPT Providers to enable AI features in .NET Apps under the new ServiceStack.AI namespace in the dep-free ServiceStack.Interfaces package.

The implementations for these abstractions are maintained across NuGet packages in accordance with their dependencies:

• ServiceStack.Aws - AI & GPT Providers for Amazon Web Services
• ServiceStack.Azure - AI & GPT Providers for Microsoft Azure
• ServiceStack.GoogleCloud - AI & GPT Providers for Google Cloud
• ServiceStack.AI - AI & GPT Providers for OpenAI APIs and local Whisper and Node TypeChat installs

These abstractions and implementations enable .NET projects to add AI-powered natural language features whilst decoupling their Speech-to-text and ChatGPT requirements from any single implementation where they're easily substituted

The TypeScript team have sought a simple approach to enable AI-powered features that instead of relying on engineering sophisticated prompts to instead use TypeScript type's system to define the machine readable model LLMs should return and then if necessary to use TypeScript compiler's Schema validation errors to enable auto correcting prompts to guide ChatGPT into returning valid responses that our App's can understand.

To show the versatility of this approach we've implemented the All TypeChat Examples in .NET which in addition to supporting 5 different Speech-to-text providers also supports utilizing a pure .NET approach of generating TypeChat's prompt in C# and using Semantic Kernel to connect with your preferred Chat GPT provider or utilizing node's TypeChat library to interface with ChatGPT where it benefits from TypeScript schema validation and auto-retry of invalid responses with auto correcting prompts.

The new ServiceStack.GoogleCloud package contains functionality for integrating with Google's Cloud Platform, including GoogleCloudVirtualFiles Virtual Files Provider enabling usage of Google Cloud's managed Storage that's easily substitutable with other VFS providers from AWS S3, Azure Blob storage, Cloudflare R2 or local File System.

The GoogleCloudSpeechToText provider implements ServiceStack.AI's Speech-to-Text abstraction for providing transcription services using Google Cloud's Speech-to-Text v2 API

Razor Press is a Razor Pages and Markdown powered alternative to Ruby's Jekyll & Vue's VitePress that's ideal for generating fast, static content-centric & documentation websites. Inspired by VitePress, it's designed to effortlessly create documentation around content written in Markdown, rendered using C# Razor Pages that's beautifully styled with tailwindcss and @tailwindcss/typography.

The resulting statically generated HTML pages can be easily deployed anywhere, where it can be hosted by any HTTP Server or CDN. By default it includes GitHub Actions to deploy it your GitHub Repo's gh-pages branch where it's hosted for FREE on GitHub Pages CDN which can be easily configured to use your Custom Domain.

The Razor SSG template continues to see improvements for creating richer static websites and Blogs:

• RSS Feed for Blog Posts
• New Razor Press Markdown Containers
• Support for Markdown Includes
• Meta Headers support for Twitter cards and Improved SEO
• Blog Posts can include rich Vue Components
• Light and Dark Mode Query Params
• Threads and Mastodon Links for Blog Authors

The latest release of OrmLite includes Bulk Inserts implementations for each supported RDBMS to support the most efficient ways for inserting large amounts of data, which is encapsulated behind OrmLite's new BulkInsert API which are up to 138x times faster than traditional single INSERT statements.

In addition to an optimal default Bulk Insert implementation, it can also be configured to execute batched SQL Insert statements with configurable batch sizes which enjoys broad support across all RDBMS's.

JSON Lines is an efficient JSON data format parseable by streaming parsers and text processing tools like Unix shell pipelines, whose streamable properties is making it a popular data format for maintaining large datasets like the large AI datasets maintained on huggingface.co that's now accessible on Auto HTML API pages.

The JSON Lines data format behaves the same way as the CSV format where it will automatically serialize the first IEnumerable property, including for all AutoQuery APIs which now benefit from a streamable JSON data format.

CreatorKit is a simple, customizable, self-hostable alternative solution to using Mailchimp for managing an organization's mailing lists, accepting newsletter subscriptions, defining customizable email layouts and templates and sending rich HTML emails to your Customers and subscribers using your preferred SMTP provider.

It also provides a private alternative to using Disqus to enhance websites with a threading and commenting system on your preferred blog posts and website pages that you want to be able to connect with your community on.

The new <SidebarLayout> is a high-productivity Vue Component that combined with the <AutoQueryGrid> content can save an invaluable amount of time in being able to rapidly create custom Admin UIs.

The blazor-vue now includes a Client Admin UI showing how we can replicate most of Locode's Auto UI in a customizable Vue App from a single index.html page. It also includes an example of a Server Rendered Admin UI for those that prefer to develop Multi Page Apps with Razor Pages.

We've been working on different patterns of development to enable ChatGPT to leverage an App's ServiceStack APIs to solve given tasks. This is done through various prompting techniques which allows the Agent to reason about the context of the conversation and make decisions to reach for different 'tools' (your APIs) when trying to achieve a specific goal.

For anyone wishing to incorporate AI into their systems we've created a introductory video into the techniques of how to leverage Large Language Models (LLMs) like GPT so they can make informed decisions on which of your internal APIs they should call to accomplish a given task described in natural language.

Following blazordiffusion.com which was created to showcase ServiceStack's Blazor Server and Blazor WASM project templates and components, we've rewritten a new Stable Diffusion App in Vue adopting a Simple Modern JavaScript approach to showcase the Razor SSG Project Template and Tailwind Vue Component Library available at:

https://diffusion.works

Vue Diffusion is built differently from other Razor SSG Apps as instead of being pre-rendered from static content like Markdown documents, it's prerendered from https://blazordiffusion.com APIs to render its dynamic Albums, Top and Latest pages at deployment which it does by configuring the App's Service Gateway to reference external Blazor Diffusion APIs.

We're celebrating reaching 150M Total Downloads with a brand new website, rewritten from Ruby's Jekyll and jQuery with an exciting new Razor SSG project template enhanced with Vue 3 components for client interactivity features.

The new Razor Pages & Markdown powered template takes advantage of the advances made in the last few releases with our npm dependency-free approach to Simple, Modern JavaScript, the built-in support for Prerendering Razor Pages and the rich Tailwind Vue Component Library to create an enjoyable experience for creating Fast, FREE, beautiful, CDN-hostable static generated websites & blogs.

We're excited to announce our new razor-ssg project template - a Razor Pages powered Markdown alternative to Ruby's Jekyll & Next.js that's ideal for generating static websites & blogs using C#, Razor Pages & Markdown.

It's now available FREE to all .NET Developers wanting to creating Fast, Beautiful Static Websites & Blogs with Razor Pages. It's FREE to create, FREE to host on GitHub Pages CDN and also designed to support running FREE from any local .NET Installs or IDEs where it can be maintained in GitHub Codespaces that you can do entirely from an iPad.

We've greatly improved the end-to-end development experience of creating Flutter Mobile Apps that integrate with your ServiceStack APIs. To demonstrate the seamless development experience, we've created a video walk through creating a new Blazor Server project that we use mix flutter to create a new Flutter App that we can use to quickly build a Mobile App to call its existing Todo .NET APIs using the built-in Typed Dart DTOs integration.

This release also includes improvements to generated Dart DTOs and servicestack Dart client library with new simplified APIs that greatly improves usage in Reactive UIs by encapsulates Successful and Failed API Responses in a single ApiResult<TResponse> value which can be passed down and bound to reactive components without any inhibitive try/catch statements.

We've also improved the development experience for developers who prefer or have existing investments in gRPC will be able to benefit from the improved development experience with mix flutter-grpc which works like mix flutter but instead adds a new Flutter gRPC App to an existing ServiceStack grpc project, with pre-configured gRPC integrations.

To demonstrate this productive workflow we've created a new video which walks through the process of creating a new Flutter App from scratch, adding a Flutter gRPC App to an existing grpc .NET project, and using mix flutter-grpc to configure the Flutter App to work with ServiceStack's gRPC Services.

The new Auto HTML Page is the best way to visualize, inspect and integrate with your APIs which provides instant utility for API consumers in consuming your APIs with a built-in API Response Visualizer, JSON syntax highlighting, integrated Postman-like UI and API SDK integration all-in-one.

A nice benefit of ServiceStack's API Design is that consuming APIs are fundamentally all done the same way in all languages, which just requires adding a dependency containing a generic ServiceClient which can be used to call any ServiceStack API using the typed DTOs copied directly from the API docs page to enable an end-to-end typed API without any external tooling or build steps.

The new AutoQueryGrid component is the last high-productivity component missing from the Vue Tailwind Component Library to reach feature parity with Blazor Tailwind Component Library.

It enables an Effortless CRUD UI without any external dependencies, tooling or build steps, generating a capability-based UI for the currently authenticated user, enabling full CRUD functionality through the App's auth-protected AutoQuery APIs, validated by the APIs Declarative Validation Rules utilizing optimal Form Inputs for each C# property type with contextual validation binding, that displays its results in a rich formatted data grid customized with APIs Declarative UI Attributes.

With access to all components needed, we've taken this opportunity to modernize all of ServiceStack's built-in UI's that were previously written with petite-vue and have rewritten them with Vue 3 and the Vue Components Library, which has become our preferred UI technology stack for all of ServiceStack's built-in UIs.

Ultimately the new Vue 3 UIs should appeal to a lot more use-cases with better reuse and customizability using the full Vue 3 framework and 3rd Party ecosystem for creating more compelling and interactive UIs.

The /api route is now being used as an opportunity to improve API Discovery by returning an App's public APIs grouped by user-defined tags with direct links to the API endpoint, viewing it in API Explorer and in Locode for AutoQuery APIs.

The new Tailwind Razor Pages & MVC Templates enable rapid development of Modern Tailwind Apps without the pitfalls plaguing SPA development:

• vue-mjs - Flagship Vue.mjs template with OrmLite, AutoQuery, boosted htmx links & static pre-rendered blogs
• razor - Simple Razor Pages Template without DB or pre-rendering
• mvc - Want to use MVC Identity Auth and Entity Framework
• web-tailwind - Empty tailwind template with no web framework configured
• vue-vite - Vite + TypeScript in a simpler JAMStack Vite SPA App
• vue-ssg - Vite + TypeScript in an advanced JAMStack Vite SSG App

To maximize productivity, all new Vue Tailwind templates are pre-configured to use the feature-rich Vue 3 Taiwlind Library.

@servicestack/vue is our growing Vue 3 Tailwind component library with a number of rich Tailwind components useful in .NET Web Apps, including DataGrids, Auto Forms, Modals, Slide Overs, Navigational Components, Formatters, standard HTML Form Input controls inc. FileInput, Autocomplete, TagInput - all with integrated contextual validation binding.

It's our cornerstone library for enabling a highly productive dev model across our Vue.js Tailwind Project templates that we'll be continuing to invest in to unlock even greater productivity - watch this space!

The new ES6 classes provide a productive type-safe development model during development but can also be referenced as-is in JS Module scripts and run natively in browsers to enable instant typed API integrations without any build tools!

To achieve this the ES6 classes are annotated with JSDoc type hints in comments which enjoys broad support in IDEs and tools like TypeScript where it can be used to provide type information in JavaScript files.

They're now a first-class Add ServiceStack Reference language supported language complete with IDE integration in the latest ServiceStack Plugins for VS .NET and JetBrains IDEs.

Prerendering static content is a popular technique used by JAMStack Apps to improve the performance, reliability and scalability of Web Apps that's able to save unnecessary computation at runtime by generating static content at deployment which can be optionally hosted from a CDN for even greater performance.

As it's a valuable performance optimizing technique it's included in the vue-mjs template to show how it can be easily achieved within a Razor Pages App. Since prerendered content is only updated at deployment, it's primarily only useful for static content like markdown powered blogs.

For those interested in utilizing this optimization we've published details on how this works in the Prerendering Razor Pages blog post.

Tailwind has revolutionized how we style our Web Apps with its mobile first design system that's dramatically simplified creating maintainable responsive Web Apps. It also excels at adding support for Dark Mode with its first-class dark: modifier allowing the use of standard tailwind classes to specify what elements should look like when viewed in Dark Mode.

We're happy to announce that Dark Mode support has been added to all ServiceStack.Blazor Tailwind components and all Blazor Tailwind project templates where you'll be able to toggle on/off Dark Mode with the new DarkModeToggle component.

The ServiceStack.Blazor component library continues to expand with exciting new Components and improvements, including:

• Autocomplete - Rich content Input to quickly search & select items
• TagInput - UX friendly input for managing a list of strings like words or tags
• FormStyle.Card - Render Auto Forms from POCO classes in a Card Layout
• NavList - Beautiful Nav Links list component with Icons + Descriptions
• Colored Buttons - Render buttons in different primary Tailwind colors
• SelectInput Expressions - Declaratively define Select Input Options
• Custom Edit & Create Forms - Use forms in custom AutoQueryGrids

The goal of our increasing Blazor investments is to enable a highly productive and capable platform for rapidly developing a majority of internal Apps CRUD functionality as well as enabling a hybrid development model where the management of Back office supporting tables can be quickly implemented using custom AutoQueryGrid components freeing up developers to be able to focus a majority of their efforts where they add the most value - in the bespoke Blazor UI's optimized customer-facing UX.

To best demonstrate its potential we've created blazordiffusion.com - a new ServiceStack.Blazor App front-end for Stable Diffusion - a deep learning text-to-image model that can generate quality images from a text prompt. It's a great example of Hybrid Development in action where the entire user-facing UI is a bespoke Blazor App that's optimized for creating, searching, cataloging and discovering Stable Diffusion generated images, whilst all its supporting admin tasks to manage the back office tables that power the UI were effortlessly implemented with custom AutoQueryGrid components.

The recommendation to access DB's directly in Blazor Server components 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 Blazor WASM.

To achieve the best of both worlds, we've enabled support for utilizing the In Process 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.

We're excited to announce exciting new Blazor Components enabling a compelling a Rapid Application Development platform for Blazor Apps delivering many of the productivity benefits previously limited to Locode.

Our new native Blazor Components allows for a beautiful progression story where you can start with a Database-First Locode solution to instantly generate Data Models and CRUD APIs around your existing databases that thanks to the new AutoQueryGrid Blazor component will be able to trivially implement both CRUD UI's and optimized Blazor UIs in the same Blazor App.

We're happy to announce our new Blazor Server App template offering a number compelling advantages over Blazor WASM, including:

• 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

ServiceStack.Blazor Components gives you the ideal development workflow without compromise. Effortless, highly productive, API integrated Rich Blazor UI Components with 100% Server model reuse and integrated contextual validation.

To better showcase our growing Blazor functionality we've created new Blazor Gallery websites showcasing usage of available rich Blazor Components for rapidly develop beautiful Tailwind Web Apps available in both Blazor Server and Blazor WASM Web Apps.

We've continued improving our story around Code-First DB Migrations and have created a new video demonstrating how it can be used to maintain DB Schema migrations under a typical development workflow.

As they encourage a structured workflow for incremental development of new App features we've upgraded all modern jamstacks.net templates to adopt DB Migrations for creating and populating their App DB.

A benefit of DB Migrations being implemented in a library instead of wrapped up behind an external tool, is that it's better integrated and more versatile in supporting more executable options like being able to run from code, a feature the new MigrationTasks Explicit TestFixture benefits from enabling DB Migrations to be run or debugged directly from within your IDE.

We're excited to share the next release of ServiceStack which sees the introduction of our simple Database Migration solution with Code-First DB Migrations which advances OrmLite's light-weight code-first development approach with a simple change based migration solution that facilitates the code-first development workflow of OrmLite.

Starting from a seamless quick install and supporting multiple running options from command-line tooling, IDE run npm scripts, run, debug & verify from unit tests and integrated with our GitHub Action deployments where only successful migrations are deployed.

Instead of relying on generation by an opaque tool, this code-first approach treats DB Migrations like any other maintainable & logically structured code written by developers where it maintains a connected audit history in source control together with the feature that needs the schema changes.

The Redis Admin UI lets you manage your App's configured Redis Server with a user-friendly UX for managing core Redis data types, simple search functionality to quickly find Redis values, quick navigation between related values, first class support for JSON values and a flexible command interface and command history to inspect all previously run redis commands that's easily editable & rerun.

The new built-in Database Admin UI lets you quickly browse your App's configured RDBMS schemas and tables, which without any additional configuration your App's configured databases, their schemas, tables and any registered named connections will be navigable from the home page where they'll be browsable with a familiar tabular search results grid, similar in appearance and functionality to Locode's Auto UI where their resultsets can each be personalized with flexible query preferences and filtering options that's persisted across browser restarts.

The feature-rich Blazor WASM Tailwind template us 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 WASM Apps.

Having achieved the best architecture for delivering max value and performance with our jamstacks.net templates, the last expensive vital component used in most Web Apps is hosting of their expensive managed databases. Despite most RDBMS's being OSS and free of licensing costs, major cloud companies continue to charge artificially high hosting costs to provide redundant hosting of App data.

Litestream lets us avoid these expensive hosting costs by providing transparent per-second replica backups to inexpensive managed storage, enabling latency-free queries, simplified hosting architectures at vastly reduced hosting costs.

The new Request Logging & Profiling UIs bring an invaluable new level of observability into your App, from being able to quickly inspect and browse incoming requests, to tracing their behavior from their generated events in the new Diagnostic Source capabilities added all throughout ServiceStack, which both power the new UIs and enables new introspectability from code where you can now to tap in to inspect & debug when each diagnostic event occurs.

The DB Validation feature leverages the existing Declarative Validation infrastructure where it enables dynamically managing Request DTO Type and Property Validators from a RDBMS data source which immediately takes effect at runtime that carries the same performance profile at runtime as they can be optionally cached where they'll only need to be re-hydrated from the database after modification.

We're excited to announce Locode, our Rapid Application Development solution to quickly develop beautiful Full Stack CRUD Apps around AutoQuery APIs, suitable for a wide number of use-cases including:

• Rapid prototyping by creating an instant UI around existing Database-First RDBMS tables
• Declarative Code-First development model with unprecedented customizability (exportable from Database-First)
• Hybrid Apps with a custom UI to optimize common workflows whilst using Locode's Auto UI to manage Back office tables

As Locode's UI is built on top of ServiceStack's industrial strength AutoQuery APIs, Hybrid Apps can benefit from its superior end-to-end typed development model for creating Web, Mobile & Desktop Apps.

Using AutoQuery's AutoGen enables the quickest way to modernize an existing database by dynamically creating Data Models & AutoQuery CRUD APIs from RDBMS table schemas at runtime.

Locode provides a highly functional UI out-of-the-box that doesn't rely on code-gen that allows you to only override the Custom UI or Custom API implementation when needed resulting in a significantly smaller code-base to maintain as reflected in the comparitive code-bases of a customized Northwind Locode App vs the Northwind code-base of a popular RAD code-gen tool for .NET

Code-First is the natural development model of AutoQuery Services which facilitates the majority of a System and its UI can be developed from simple, declarative C# POCOs to define the underlying RDBMS Schema Data Models and the precise typed API DTO Contracts of their surrounding AutoQuery & CRUD APIs. The Data and Service models can be further enhanced by ServiceStack's vast declarative attributes where a significant amount of behavior, functionality and customization can be defined, ranging from:

• Customize how Data Models map to DB Tables & enlist RDBMS features
• Customize Serialization & API behavior
• Define AutoQuery & CRUD API behavior
• Define Validation Rules and Authorization restrictions
• Annotate & Document APIs
• Customize UI Behavior & Appearance

Locode's declarative dev model lets you focus on your new App's business requirements where its data model, API capabilities, input validation & multi-user Auth restrictions can be defined simply using annotated C# POCOs. This provides immense value at the start of the development cycle where functional prototypes can be quickly iterated to gather business requirements

Once requirements have solidified, its typed AutoQuery APIs can easily be reused to develop custom UIs to optimize important workflows.

Talent Blazor is a new App showcasing an example of this where its entire back-office functionality can be managed through Locode whilst an optimized Blazor WASM App is created to optimize its unique workflow requirements which also benefits from the superior productive dev model of its Typed APIs.

We're starting off 2022 eclipsing an impressive milestone having crossed 100M+ NuGet downloads which we're celebrating by making ServiceStack FREE for Individuals & collaborative OSS Projects.

We've also created 2 new community spaces for ServiceStack developers to engage with each other:

• ServiceStack/Discuss
• #ServiceStack channel on Discord

These new spaces are welcome to all users of the framework that we hope together with the new free licenses will encourage developers build and share their amazing creations with each other! 🎉

Now built into every ServiceStack v6 App is API Explorer - an instant integrated Postman and Swagger UI alternative to quickly Call and Explore your APIs.

The entire API Explorer UI is driven by the rich metadata around your APIs and AppHost's registered plugins capturing greater knowledge about your APIs and is able to provide a smarter, richer and more optimized UX than what would be possible going through lowest common denominator specs like Open API.

With envious performance and unmatched customizability, API Explorer lets you easily incorporate gorgeous, rich, interactive API Documentation API Consumers will love who'll be able to read its source code in their preferred programming language and easily call from their existing Client Apps.

Our new Blazor WebAssembly (WASM) template is ideal for teams with strong C# skills building Line Of Business (LOB) applications. Utilizing an API First development model, the C# Blazor front-end is able to take advantage of the clean separation of ServiceStack APIs to enjoy instant frictionless 100% reuse of API Types as-is, without any reliance on any tooling or unproductive out-of-sync code-gen build steps interrupting developers workflow.

Together with new .NET Service Clients Apis it results in the ideal productive dev model to bind Blazor UIs to ServiceStack APIs.

Templates make use of ServiceStack.Blazor a new package of integrated functionality with ServiceStack, inc. JSON API HttpClient Factory, API-enabled base components & themable Bootstrap + Tailwind UI controls.

In addition to TODO MVC and CRUD UI examples demonstrating its productive dev model, it also includes pre-rendering solutions for instant load times & GitHub Actions for effortless optimal Jamstack CDN deployments.

ServiceStack's new jamstacks.net templates encapsulates the latest technologies at the forefront of modern web development to deliver both a great developer experience and performant end-user UX.

Jamstack (JavaScript, APIs, and Markup) is a modern architecture pattern to build fast, secure and easy to scale web applications where pre-rendering content, enhancing with JavaScript and leveraging CDN static hosting results in a highly productive, flexible and performant system that takes advantage of CDN edge caches to deliver greater performance & efficiency at lower cost.

It's quickly becoming the preferred architecture for modern web apps with benefits extending beyond performance to improved Security, Scale, Maintainability, Portability, Developer Experience & lower costs with your App's pre-rendered static UI assets on Content Delivery Network (CDN) edge caches close to users locations.

These new templates represent the best-in class experiences for their respective React, Vue & Blazor WASM ecosystems each, packed with features & examples common in many websites including Integrated Auth, rich Markdown content as well as TODOs MVC and CRUD examples with built-in contextual validation binding. As such they're now recommended over our existing SPA and C# MVC Templates.

We've cut this release cadence short to focus on putting out a quality release to take advantage of the newest and best .NET runtime yet!

In a lot of ways .NET 6 marks the start of a new era for .NET with the first LTS release after the end of the .NET Framework and .NET Standard with only 1 actively developed runtime going forward.

We're moving full-steam ahead and have standardized our new features onto .NET 6 with:

• All project templates upgraded to .NET 6
• net6.0 TFM builds added to all packages
• Embracing .NET 6 new Hosting Model for mix
• v4.5 .NET Framework Deprecation Notice

Visual Studio 2022 now has support for Add ServiceStack reference for C#/F#/VBNET/TypeScript!

ServiceStackVS can be found in the Extension Marketplace, and is installable straight from Visual Studio 2022.

We're now embracing .NET 6's idiom and have rewritten all our mix gist config files to adopt its HostingStartup which is better able to load modular Startup configuration without assembly scanning.

This video guide shows how you can migrate your existing startup modules to use .NET 6 Hosting Model.

Python is one of the worlds most popular programming languages which excels in a number of industries thanks to its ease of use and comprehensive libraries.

To maximize the experience for calling ServiceStack APIs within these environments ServiceStack now supports Python as a 1st class Add ServiceStack Reference supported language which gives Python developers an end-to-end typed API for consuming ServiceStack APIs, complete with IDE integration in PyCharm as well as built-in support in x dotnet tool to generate Python DTOs for a remote ServiceStack instance from a single command.

Python has solidified itself as a powerhouse in Data Science and Machine Learning thanks to its best-in-class libraries as well as being at the forefront of Interactive Computing with its native support in Jupyter Notebooks - a popular realization of Donald Knuth’s Literate Programming paradigm where executable code is interlaced in a live document with natural language documentation, rich markup and embedded media. It’s become an invaluable medium for data science, scientists and researchers where it’s often used as an advanced REPL environment for data and computation exploration whose resulting knowledge and insights are easily captured and shared.

We’re excited to be able to join the beautiful interactive world of Jupyter Notebooks with both Simple UI and command-line tools for effortlessly generating customized Notebooks around typed ServiceStack APIs for Jupyter’s premier support for Python.

In addition to Python we've also extended support for generating customized pre-populated C# and F# Jupyter Notebooks by leveraging dotnet/interactive Jupyter kernel’s which allows C# and F# .NET Developers to join Jupyter's interactive live programming paradigm which they can either choose to run locally in the next gen JupyterLab UI or directly within VS Code using .NET Interactive's VS Code extension.

Notebooks have also become a popular medium for sharing institutional data and computational knowledge thanks to being able to capture and embed execution output and support for exporting in multiple popular document formats as used by GitHub with their Auto Preview support for Notebooks. We also simplify configuring a Notebook GitHub repo to support executing C# and F# Notebooks in mybinder.org FREE cloud hosting services with our docker-jupyter mix template.

Building upon our native end-to-end typed solutions, we're excited to announce Instant Client Apps to provide instant utility and value around your ServiceStack Services where your API consumers can use the Auto generated UI to craft API Requests in their preferred programming language:

We've begun to fully embrace GitHub Actions from this release to help quickly setting up CI environments for new and existing ServiceStack project templates by automating them into building and running tests on each commit before publishing, dockerizing & deploying them on each GitHub Release. The templates leverage mix to work like lego pieces where they can be combined to achieve your preferred automation workflow.

In addition to the Refresh Token support & built-in Inspect utils all ServiceStack’s generic Service Client libraries in all languages have received a number of updates to improve their consistency and overall development UX.

To see the rapid development of AutoQuery in action we've created a quick demo showing how to create a simple multi-user Booking System from an empty web project, mixed in with the preferred RDBMS & Auth layered functionality, before enabling Validation, AutoQuery, Admin Users & CRUD Event Log plugins - to lay the foundational features before building our App by first defining its Booking data model & its surrounding Query, Create, Update and Soft Delete Typed CRUD APIs with rich validation enforced by declarative Validation attributes and multi-layer authorization rules & access permissions protected using Authorization attributes.

We've caught a glimpse of the new User Admin Feature in the Bookings CRUD demo who utilizes it to create Employee and Manager users. The AdminUsersFeature provides Admin User Management APIs enabling remote programmatic access to your registered User Auth Repository, featuring:

• Works with existing IUserAuthRepository sync or async providers
• Utilizes Progressive enhancement, e.g. search functionality utilizes IQueryUserAuth (if exists) performing a wildcard search over multiple fields, otherwise falls back to exact match on UserName or Email
• Supports managing Auth Repositories utilizing custom UserAuth data models
• Flexible UI options for customizing which fields to include in Search Results and Create/Edit UIs
• Rich Metadata aggregating only App-specific Roles & Permissions defined in your App
• User Events allow you to execute custom logic before & after each Created/Updated/Deleted User

As mobile Apps is a target use-case for ServiceStack, this release also includes 1st class integration with Sign In with Apple OAuth provider. To assist with adoption we've also developed Sign In with Apple Integration Examples for iOS, Android & Web with working implementations for Flutter iOS/Android & SwiftUI Apps.

Another exciting development in this release is the successor to Admin UI: ServiceStack Studio! - a capability-based UI to manage multiple remote ServiceStack instances from either a Chromium Desktop App or cross-platform .NET Core Web App.

The richer metadata in ServiceStack Services allows Studio to logically group Services around Data Models, enabling its high-level semantic features like its native data-grid like UX over all AutoQuery Services to quickly discover, search, create, update and delete entities based on the available AutoQuery APIs and whether Authenticated Users have access to them.

ServiceStack also reached maximum autonomy for a Services framework where in addition to AutoQuery automatically providing your Services implementations, Studio providing its instant UI, ServiceStack also gained the capability to generate your entire API! Including Typed API contracts, data models, implementations & human-friendly pluralized HTTP API routes over an existing System RDBMS's tables!

ServiceStack's AutoGen enables a number of exciting possibilities, predominantly it's the fastest way to ServiceStack-ify an existing systems RDBMS where it will serve as an invaluable tool for anyone wanting to quickly migrate to ServiceStack and access its functionality ecosystem around ServiceStack Services:

An unintended consequence of AutoGen that's potentially universally appealing to even non .NET developers is that it's also a way to instantly generate Types for all RDBMS tables in all of ServiceStack supported client languages, which thanks to being configurable in a Sharp App can be executed from the command-line using the dotnet tools

We're super excited to open the year with the premier feature in this release ServiceStack gRPC, our highly-productive entry into the gRPC universe with a number of value-added additions that makes developing and consuming gRPC Services a joy with USPs that leverages and preserves your existing knowledge and investments and maximizes the utility of your Services offering unprecedented value for your development efforts.

With the release of .NET Core 3.1 LTS we've standardized our Project Templates and tools to .NET Core 3.1 LTS whilst continuing to support existing .NET Core 2.1+ and .NET Framework projects including ASP.NET Core Apps on the .NET Framework.

Ordinarily we'd have a longer release cadence in between releases with more features, but with the recent release of .NET Core 3 we've cut this release cycle short so we can release a version of ServiceStack compatible with .NET Core 3+. Other than that the major focus on this release was #Script with many new features we're excited to share after covering the ServiceStack changes.

We've seen great reception of Gist Desktop Apps from the last v5.6 release with a nice shoutout from Jon Galloway in the ASP.NET Community August Stand up, a featured blog post from Scott Hanselman as well features in Hacker News and Reddit.

We've since further enhanced #Script capabilities in this release making it more functional then ever, broadening its appeal in its growing list of use-cases.

We want to dramatically simplify and improve the experience for configuring ASP.NET Core Apps and make them truly composable, where we can drop-in files that auto configures itself with both ASP.NET Core and ServiceStack's AppHost so they can encapsulate an entire feature and provide instant utility without needing to wade through different steps of how they should be manually configured at different places in your Startup configuration class.

To complete the picture of making it easy as possible to compose ASP.NET Core Apps we've created the mix dotnet tool to easily install features which can be installed with:

$ dotnet tool install --global mix

The mix tool is designed around applying ASP.NET Core features captured in GitHub gists to your local .NET Core projects.

Then choosing which features you want to add to your project with mix <name>, e.g:

$ mix redis

To lay the foundation for richer and more tightly integrated UI controls, we've created UI and common component libraries for the 3 most popular JS frameworks:

• @servicestack/vue
• @servicestack/react
• @servicestack/angular

All new Single Page App Project Templates have been pre-configured to use these libraries which will make it a lot easier to deliver new UI components and updates to existing SPA Apps with just an npm upgrade.

Before we get into unpacking this release we're happy to announce that we've now eclipsed 10 years since our first commit!

I'd like to take this milestone to thank our thousands of Customers we've had the pleasure to serve and see our Software used which has amassed more than 27,000,000+ total downloads on NuGet and to see the uptick in adoption of some of our unique features like Add ServiceStack Reference which has been used more than 88,000 times to generate native Typed DTOs amongst its 8 supported languages.

As we continue enhancing ServiceStack's scripting support with exciting new features, it no longer made sense to call our dynamic scripting language "Templates" which is just one of the many use-cases #Script enables.

#Script is typical of a popular dynamic template language you'd find in other platforms, using the ubiquitously familiar mix of JavaScript Expressions which for increased wrist-friendly readability can be easily composed together using the Unix | operator as embraced by Vue.js filters and Angular's Template Expressions whist the Script Statement Blocks adopt the universally adopted Handlebars-like syntax that's ideal for rendering dynamic pages.

Our new app build tool is packed with features for "Chromitizing" any .NET Core Web App into a .NET Core Windows Desktop App that's as easy as installing the app tool:

$ dotnet tool install -g app

and using it to run your .NET Core Web App's .dll, e.g:

$ app MyApp.dll

Where it will run your .NET Core App and host it inside an Chromium Embedded Framework (CEF) browser.

This provides instant utility for being able to deploy .NET Core Apps end users can run locally using Chrome's leading and consistent rendering engine within a Windows Desktop Application.

Major rework was performed across the ServiceStack.Text and ServiceStack.Common foundational libraries to replace its internal usage of StringSegment with .NET's new high-performance Span and Memory Types primitives which are now used for all JSON/JSV deserialization and many other String utilities.

The new Span<T> and ReadOnlyMemory<char> Types is the successor to StringSegment which are both allocation-free, but Span also enjoys additional runtime support as a JIT intrinsic for improved performance.

This change was primarily an internal refactor so there shouldn't be any user visible differences except for the addition of the System.Memory dependency which contains the new Memory types. As a general rule we're averse to adopting new dependencies but the added performance of these new primitives makes it a required dependency for maintaining high-performance libraries.

We're super excited to announce first-class support for Dart and Flutter! - Google’s premier new mobile UI framework for crafting high-quality native interfaces for iOS and Android from a single code-base in record time with a Reactive development model simplifying the effort for building Complex UIs in similar vein to development models pioneered in popular JavaScript frameworks like React, React Native, Vue and Angular. It's offers a beautiful blend of rapid development cycles with its built-in Hot Reloading giving you instant iterative feedback of changes to your Mobile App in milliseconds, whilst still offering high-performance native experiences at runtime where Dart code is AOT compiled into native ARM in iOS and Android.

Historically ServiceStack releases are focused around "Major release schedules" published along with detailed Release Notes describing new features and changes added in each release. All packages are published together in "lockstep" with the same version number so the effort to upgrade ServiceStack projects can be done all at same time, with low frequency.

Whilst we want to minimize the effort for Customers to upgrade we also want to make any fixes or enhancements to the previous release available sooner as there are often fixes reported and resolved immediately after each release and made available in our pre-release packages on MyGet that most Customers wont get until the next major Release on NuGet.

The HelloMobile project has been rewritten to use the latest v5 .NET Standard 2.0 and .NET Framework clients and contains multiple versions of the same App demonstrating a number of different calling conventions, service integrations and reuse possibilities for each of the following platforms:

• WPF
• UWP
• Xamarin.Android
• Xamarin.iOS
• Xamarin.OSX
• Xamarin.Forms
  • iOS
  • Android
  • UWP