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:
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.dev.
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:
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.dev, 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:
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
|Locode Northwind||Radzen Northwind|
|~120 lines of C#||~4500 lines of C# (generated)|
|29 lines custom Home Page||10k+ lines of Angular HTML/TS (generated)|
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:
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:
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.
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:
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:
IUserAuthRepositorysync or async providers
IQueryUserAuth(if exists) performing a wildcard search over multiple fields, otherwise falls back to exact match on
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.
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
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:
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 is typical of a popular dynamic template language you’d find in other platforms, using the ubiquitously familiar mix of
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
$ dotnet tool install -g app
and using it to run your .NET Core Web App’s
$ 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
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.
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.
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: