Blazor.Animate is a new MIT-licensed Blazor-component which allows you to easily add fade, slide and zoom-effects into your Blazor applications. Blazor.Animate is powered by the AOS-library.


Blazor.Animate is available through Nuget. Its source code and project home can be found from GitHub.

What can it do?

With Blazor.Animate you can animate how other components are brought into the view.

How to use it?

To animate a component, wrap it inside Animate-component and use the Animation-parameter to define the animation:

    <Animate Animation="Animations.ZoomIn" Duration="TimeSpan.FromSeconds(0.5)" >

Is it really that easy?

Yes, after you have added the required Nuget-package and JSInterop. For guidance, please see the readme for a more throughout Getting Started guide: https://github.com/mikoskinen/Blazor.Animate

What animations are supported?

Here’s the built-in animations provided by Blazor.Animate:

  • Fade
  • FadeIn
  • FadeUp
  • FadeDown
  • FadeLeft
  • FadeRight
  • FadeUpRight
  • FadeUpLeft
  • FadeDownRight
  • FadeDownLeft
  • FlipUp
  • FlipDown
  • FlipLeft
  • FlipRight
  • SlideUp
  • SlideDown
  • SlideLeft
  • SlideRight
  • ZoomIn
  • ZoomInUp
  • ZoomInDown
  • ZoomInLeft
  • ZoomInRight
  • ZoomOut
  • ZoomOutUp
  • ZoomOutDown
  • ZoomOutLeft
  • ZoomOutRight

Are there any samples of these animations?

Blazor.Animate’s sample site contains a testbed-page which can be used to check all the animations: https://animateblazorsamplessvc.azurewebsites.net/testbed


Is that all?

There’s also easings. And default animations. And named animations. And anchoring.

All these are demonstrated in the sample and in the readme.

Did you do all the animations?

No. All the animations are provided by AOS.

Where to learn more?

The best way to learn more is to head to GitHub and to browse the source or the sample code. If you have any questions, please submit a GitHub issue on the repo.


There’s a new version of Adaptive Cards for Blazor available: version 1.1.0 has just been released and it adds support for Action.ToggleVisibility.

ToggleVisibility adds an ability to create cards where card elements can be hidden or shown runtime. It’s quite similar to ShowCard, but instead of the action targeting a card inside a card, ToggleVisiblity can target any element, like a container or an image.

Quick introduction of Adaptive Cards for Blazor

Adaptive Cards for Blazor is a community project that provides Adaptive Cards support for your Blazor applications. Here’s some interesting features provided by the project:

  • Templating: Combine models (objects) and the schema.
  • Card Collections: Display a list of cards based on model and use template selector to customize the output.
  • Action support: Handle Submit and OpenUrl actions using C#.
  • Native .NET-based solution: Blazor Adaptive Cards is based on the official .NET SDK for Adaptive Cards.

The roadmap

Now that version 1.1.0 is ready, the main focus will be on versions 2.0.0 and 3.0.0. The current goal is to release 2.0.0 in November 2019. The version 2.0.0 will add .NET Core 3.1 support to Adaptive Cards for Blazor.

Even more important is the 3.0.0 version. The aim is to release preview of 3.0.0 in May 2020 with support for .NET 5’s Blazor WebAssembly. 

Of course, minor versions may be released for bugfixes and for new features.

For the up-to-date roadmap, please see the following page: https://www.adaptivecardsblazor.com/roadmap.html

How to learn more

As before, the best way to start learning about Adaptive Cards for Blazor is the “Getting Started” –tutorial. There’s also a “Quick start” available.

There’s also more than 40 samples available which show you how to use features like Card Collections and how to handle submit actions in C#.

For the source code and current issues & feature requests, please see GitHub.


Adaptive Cards for Blazor is a community project that provides Adaptive Cards support for your Blazor applications. Adaptive Cards are a way to exchange content in a common and consistent way. Adaptive Cards can be integrated into different applications like Microsoft Teams and Outlook. Adaptive Cards can also be integrated into custom applications built with .NET, iOS and JavaScript. And now Blazor is also supported.

The project’s home site with documentation can be found from https://www.adaptivecardsblazor.com/ and I especially recommend you to check out the Getting Started guide.

There’s also more than 40 samples available through the Sample Site. But please note that the samples are currently hosted on a free Azure App Service plan. If the sample site gets too much traffic, Azure will throttle/take down the site. You can run the samples on your own computer by cloning the repository.

Adaptive Cards for Blazor version 1.0.0 is available through NuGet and the source code and issue list is available through GitHub.


Here's few of the most notable features of this project:

  • JSON-support: Create and display Adaptive Cards from the JSON-schema.
  • Templating: Combine models (objects) and the schema.
  • Card Collections: Display a list of cards based on model and use template selector to customize the output.
  • Action support: Handle Submit and OpenUrl actions using C#.
  • Native .NET-based solution: Blazor Adaptive Cards is based on the official .NET SDK for Adaptive Cards.

One of the most powerful features provided by Adaptive Cards for Blazor is Card Collections. Card Collections can be used to display a collection of cards, based on a list of models (C# objects) and a schema. This allows you to easily transform your application from this:


To this:


Here’s the required code for displaying a Card Collection:

    <CardCollection Models="@forecasts" Schema="@schema"></CardCollection>

Card Collections can be animated with JS & Css libraries and in the example above, AOS was used. For more information about animations, please see the documentation.

Another powerful feature of the project is handling actions in C#. There’s couple ways of doing this, both described in the documentation. Here’s a quick sample of using OnSubmitAction:

<AdaptiveCard Schema="@Schemas.SimpleSubmit" OnSubmitAction="OnSubmit"></AdaptiveCard>

@code {
    string actionDetails = "";

    private void OnSubmit(AdaptiveCards.Blazor.Actions.SubmitEventArgs eventArgs)

Quick Start

The Getting Started guide teaches you how to build Blazor applications using Adaptive Cards for Blazor. It's the recommended source of information for those who are new to Adaptive Cards.

For a quick introduction, here’s how to add Adaptive Cards for Blazor into your app and to render your first Adaptive Card:

Add NuGet

Install-Package AdaptiveCardsBlazor
Configure Startup.cs

        public void ConfigureServices(IServiceCollection services)


Configure _Imports.razor

@using AdaptiveCards.Blazor

Add JS interop into _Host.cshtml

    <script src="_content/AdaptiveCardsBlazor/adaptiveCardsJsInterop.js"></script>

Create the schema in your component

@code {
    string schema = @"{
      ""$schema"": ""http://adaptivecards.io/schemas/adaptive-card.json"",
      ""type"": ""AdaptiveCard"",
      ""version"": ""1.2"",
      ""body"": [
          ""type"": ""TextBlock"",
          ""text"": ""Adaptive Cards for Blazor simple example""

Render the card by adding component into page

<AdaptiveCard Schema="@schema"></AdaptiveCard>


Adaptive Cards for Blazor targets .NET Core 3.0. Please also note that the library has been tested with the server side version of Blazor.

Fully tested and supported version of Adaptive Cards for Webassembly version of Blazor is coming shortly.


Adaptive Cards for Blazor is MIT licensed. The library uses the following other libraries:

AdaptiveCards.Rendering.Html: MIT-license
Scriban: BSD 2-Clause "Simplified" License


.NET Core 3.0 has arrived and that means Blazor is here! Happy days!

I’m still little gutted that the Razor Page & Blazor interop was scaled down so near the release as we were looking forward to enhancing our Razor Pages with a bit of Blazor magic. But at last we can still include complete Blazor pages next to Razor Pages as shown in the “Combining Razor and Blazor Pages in a Single ASP.NET Core 3 Application” post couple weeks ago. That tutorial is for last preview release of .NET Core 3 but should work without any code changes with the 3.0.

As .NET Core 3.0 is here, that means Blazor.EventAggregator, Blazor.Page and Blazor.CommandButton have all been updated to .NET Core 3.0. For a short introduction of these components, please see the previous post “Blazor.CommandButton and Blazor.EventAggregator updated for ASP.NET Core 3 RC1”.

So, what’s next? I’m happy to say that work with Blazor.AdaptiveCards is almost complete and the first release is near. As the name suggests, Blazor.AdaptiveCards will bring AdaptiveCards to Blazor and I’m quite happy of the implementation. Here’s a sneak peek:


Also, now that the server side version of Blazor is done (or at least officially released), WebAssembly-version of Blazor is quite likely starting to more attention from Microsoft and from community. Making sure that all the controls mentioned above work nicely with WebAssembly version of Blazor is a priority. There’s no known issues but more testing is needed.


Just a last minor update to both the Blazor.CommandButton and to Blazor.EventAggregator: Both of the libraries now target ASP.NET Core 3 RC 1.

The Blazor.Page component, which was released earlier this week already targets RC1 so it didn’t need an update.

Here’s a short summary of all the Blazor components mentioned above:


Blazor.EventAggregator is a lightweight Event Aggregator for Blazor. Event aggregator is used for indirect component to component communication. In the event aggregator pattern you have message/event publishers and subscribers. In the case of Blazor, a component can publish its events and other component(s) can react to those events.

Project home: https://github.com/mikoskinen/Blazor.EventAggregator

Nuget: https://www.nuget.org/packages/EventAggregator.Blazor/


Blazor.CommandButton is a lightweight button component for Blazor. CommandButton provides support for setting a guard method or property to the button. Guard methods allow you to disable or enable buttons based on some conditions. Example: If you have a button which runt the method SaveCustomer, with Blazor.CommandButton you can add a boolean property named CanSaveCustomer, which can then enable or disable the SaveCustomer-button.

Project home: https://github.com/mikoskinen/Blazor.CommandButton

Nuget: https://www.nuget.org/packages/CommandButton.Blazor/


Blazor.Page is a component designed to be used as the base component for your Blazor Pages. It offers two features for your pages: Ability to set and get page titleand ability to set data context for your page. Data context can be used similar to ViewModels in MVVM or similar to PageModels in Razor Pages

Project home: https://github.com/mikoskinen/Blazor.Page

Nuget: https://www.nuget.org/packages/Page.Blazor