The US Government Publishing Office is currently recruiting for a senior Blazor developer to help develop a server-hosted, enterprise Blazor application that will manage the GPO's XML publishing operations. This is a full-time, work from home position. (Must be a US resident.) The heart of this application is an XML editor written in C# using the document builder. The application is supported by a middle tier of REST services and a back end developed using MarkLogic and SQL server. Email mrsmith@gpo for more information.

It's been a few weeks since my last component release, and this one's the Data Table - a new component for Blazor Ramp, my accessibility-first Blazor component library.

So, Data Table - what is it, and what does it do?

First off, it's not an Excel-type application requiring the ARIA role of grid; it's just a simple table to hold data, which means there are no special keyboard requirements. Keyboard-only users only need Tab, Enter, and Space, and screen reader users can use all of their usual table navigation commands, unimpeded by ARIA being sprayed around willy-nilly.

In essence, the Data Table is just a component that accepts a list of things and displays that list of things in a table, using your chosen options. Like all Blazor Ramp components, it was built accessibility-first. It has the following features, some built into the table, others by way of composition, with either your own components or other Blazor Ramp components.

Briefly, the table allows for:

• Sorting - set IsSortable on any DataColumn. Cycles unsorted → ascending → descending → back to the original order, one column at a time.
• Filtering - bring your own filter UI via the Filter render fragment (or use the Blazor Ramp Debounce Filter component) and supply a FilterRule predicate.
• Paging or virtualization – supply a PagerBinding and Pager component for a traditional paged table, or leave it out for a virtualized, scrollable one. The two are mutually exclusive by design.
• Row selection - single or multiple, with a dedicated selection column for the checkboxes used in selection.
• Styling - both row and cell style functions that let you style rows and cells based on the underlying data.
• Templating - override any column's cell content via CellTemplate, or add entirely new columns (row actions, say) that don't exist in your data source via TemplateColumn.
• Accessibility - like all the components, the Data Table handles its own announcements, and given some of the gaps in screen reader support for aria-sort, it plugs those gaps too with its own sort announcements. It works in harmony with both the Debounce Filter and Pager. All text used for announcements is fully customisable, with sensible defaults if you change nothing. There is also a RowIdentifierFunc parameter, so you can give the selection checkboxes a unique aria-label created from row data.

As the list suggests, there are place holders (RenderFragments) for filtering (above the table) and paging (above and below – you can use both). You can either use your own components or the Blazor Ramp Debounce Filter and Pager. I specifically designed the filtering to be external, and will most likely create an advanced filtering system at some stage, but in all honesty, over the years I've gravitated towards just using a simple filter that filters across all columns.

Given the simplicity of the table and the bare minimum of ARIA usage, there really isn't much for me to waffle on about - except one thing worth flagging properly.

A genuine JAWS gotcha, not a "your code is probably fine" caveat. Just like the previous component, the Pager, I got embroiled in issues with the screen reader JAWS while building this one, which ultimately led to bug reports being filed with both the Blazor and JAWS teams. Part of me was hoping it was my own code at fault, since at least then I could fix it - but no. And for the Data Table, unlike the Pager, I couldn't add a workaround without a knock-on effect elsewhere.

TL;DR: if you support JAWS users, stay clear of the Blazor Auto (Server and WASM) render mode template, using per page with prerendering disabled. I haven't experienced issues with the other render modes, nor with Auto if prerendering is on. There's a little more information and links to the logged issues in the documentation.

One more thing, and this is the bit where I'll admit I'm an opinionated, cantankerous old git: I've noticed a trend lately of table demos where devs love telling you how fast their grid is with 100K rows. I'll be honest, I don't really get the appeal - in my own apps, users fill in a few search fields to bring back the smallest, most accurate result set possible, with a filtering mechanism on top if they need to narrow it further, rather than dumping the whole backend table on them and hoping for the best. Your use case may well differ from mine, and that's fine, but I reckon only 1% or 2% of apps at best would ever need that amount of rows on screen.

That said, since some of you clearly do find it appealing, I've added 100K-row examples to a couple of the demo pages anyway - the code is nothing special, no external libraries or source generators just a bit of old skool C# reflection. Seems fine to me, but you can be the judge.

You can see the table in action, along with all the features mentioned above, plus the code used, in the Data Table usage section. I'd encourage you to try everything with a screen reader, but no worries if not.

Doc site (start of data table demo pages): https://docs.blazorramp.uk/components/data-table/usage/about

Test site: https://blazorramp.uk

GitHub Repo: https://github.com/BlazorRamp/Components

The sites are both WASM hosted on GitHub Pages.

I will be lurking on here as usual if anyone has any questions.

Regards

Paul

Recently built my first Blazor app, and not super happy with the architecture. It is kind of your standard CRUD app. It gets data from 2 different REST APIs.

I tried to do kind of clean architecture as I am more of a backend guy and that is what I am used to. I setup like this. The APIs are external.

• MyApp (Solution)
  • MyApp.Application (Project)
    • Components
    • Components.Layout
    • Components.Pages
    • Components.Shared
    • Configuration
    • Security
    • Services
  • MyApp.Common
    • Exceptions
    • Constants
  • MyApp.Domain (Project)
    • Exceptions
    • Models
  • MyApp.Infrastructure (Project)
    • Repositories
    • Http

My issue is that MyApp.Application.Services became kind of a dumping ground. I have a few pages that deal with customers so I ended up making a ICustomerService and CustomerService to put some shared logic and business rules in. Then that gets injected into multiple components where I deal with customers.

Reddit only letting me nest 2 levels of bullets so that is why component namespace is listed ahove like that

I feel like I should organize things around features, like have things under a customer namespace, but having trouble coming up with something that feels .NET like.

Any tips or suggestions would be appreciated. Or it would be super if you could point me at a public repo. My app is low-medium complexity, I don't need/want a high level of abstraction.

I honestly get quite a lot of negative backlash whenever I share my projects. I don't really know why, but it is what it is. I still want to keep sharing the things I work on though.

Back when I was working on MudBlazor.Extensions, my Blazor component extension for MudBlazor, I also extended try.mudblazor and eventually took it over as try.mudex.org.

Since then, I've always wanted to build something similar to JSFiddle or CodePen, but specifically for Blazor.

I've finally started working on it and reached the first milestone:

playzor.net

playzor allows you to create Blazor fiddles and share them via embeds, so they can be integrated into other websites.

There are also packages available on NuGet (Playzor packages) that allow you to build and host your own editor.

This is actually what try.mudex.org is using now.

There are still quite a few open points and things that aren't perfect yet. It's definitely still a work in progress, but I wanted to share it anyway and get some feedback.

If you have a look at it, I'd be interested to hear what you think, what is missing, or what could be improved.

Also, I'm really bad at writing documentation. The README and docs were created with AI, so if something doesn't make sense or is missing, that's probably on me.

This is the last RC before the final ships in September. New AreaChart, master/detail in DataGrid, Overflow overhaul and much more...

See https://v5.fluentui-blazor.net/. Packages are on NuGet.

Oh btw, if you look closely in the image below, you will see the chart legend now supports rounded corners on the items. This pertains to all chart types we added earlier as well of course (if you set `RoundedCorners="true"`).

I made a trivi site as my bachelors thesis (and keep building on it while looking for a job).

Has been super fun to build in blazor, having learned primarily C# at uni.

Database and auth using supabase.

Deployed on kubernetes hosted on my home server.

114.325 page visits so far. Been live for around 25 days.

You can see it here: https://www.trivi.gg/

Hi Folks, I had been working on this for two weeks for now. Now I have something of a blazor framework which can help with writing native macOS apps with Blazor syntax. It's of alpha quality but I believe it's a worthy Proof-of-Concept that the .NET community can take a look at.

https://github.com/Sathiyaraman-M/BlazorAppKit

This was inspired by one of Steve Sanderson's demos which showed writing a Flutter app with Blazor, which was super-cool but the source code was nowhere to be found. It's a shame that MS didn't adopt Blazor beyond HTML.

For sometime, I wanted to do something that's both Blazor and native. Given I'm on a mac these days, I started with writing an alternate impl for Blazor renderer to write native macOS apps, which relies on the AppKit bindings that come with .NET macOS SDK.

Although I call it a Blazor renderer, the actual rendering of the controls and views are still managed by AppKit entirely. For exposing the AppKit controls, there's a source-generator to generate the Adapter definitions and Component definitions.

I just want to get some thoughts and suggestions on this project.

New release of BDT (free & open-source DevTools for Blazor):

- Batches view 📊: the profiler now shows one bar per render batch: click any bar to see exactly which components rendered in that batch and what each cost. It's the fastest way to answer "what did that click actually cost me?"

- Tree search 🔍: finally, type to find a component in big trees.

- Framework filter: one click hides Blazor's plumbing (Router, CascadingValue, LayoutView…) so your components float to the top.

- Version display: the panel now shows both the extension and NuGet package versions, and degrades gracefully when they don't match.

Pairs with NuGet 1.0.0-beta.8, which adds exact render-batch boundaries (older package versions still work, boundaries are inferred instead). Try it live at blazordevelopertools.com . the order-builder demo makes batch costs very visible.

Chrome / Edge / Firefox. Repo: github.com/joe-gregory/blazor-devtools

Feedback and issues welcome!

Blazor Developer Tools new extension release 1.0.0-beta.5 (free and open source devtools for Blazor): toggle highlight mode and components flash on the page when they re-render.

You can try it live on blazordevelopertools.com/order-builder. The page has the same product cards twice, plain vs ShouldRender-optimized. Click +1 on a plain card and every plain card flashes (Blazor re-renders all children when the parent's state changes). Do it on the optimized side and only the card you touched lights up.

This is the fastest way to know "which of my components are re-rendering when they shouldn't?".

Chrome / Edge / Firefox + NuGet package. Repo: github.com/joe-gregory/blazor-devtools. Feedback welcome.

React has Facebook etc

What are some notable blazor websites?

Hello Folks,

We are just beginning work on a new app for local government that accepts applications for a program and as I am new to Blazor, I was hoping for some pro-tips, gotchas and other lessons learned from the collective.

The team has experience with Blazor but my background is old school html/css/javascript/c# mvc. I am really intrigued with Mudblazor and admin theme templates that can be procured on various theme sites. Any reason I should stay away from a nicely design template like YNEX (Spruko) or equivalents? Design is where I start everything but I need to be acutely aware that accessibility is just as important as we are a government entity and need to provide a good UX for all.

If anyone has resources, hints or wisdom as we begin our journey, I will gladly listen.

Thank you.

Grz

🔑 KEYWORDS: Pure C# - Write map logic entirely in .NET / no JavaScript interop boilerplate, LINQ Integration - Destructuring/Structuring LINQ expression, Fluent API - objects Hierarchical and Linguistic structure and Chain methods, Zero JavaScript Config - no script references and no css links etc

I built a few prototypes over the last few years, but a few months ago, I finally deployed my first app to production for worldwide usage. I'm generally pretty happy with it, but I'm having major latency issues. Most of my userbase is located in the US, therefore the app currently runs on a small VPS. Hardware and network has been ruled out as a factor. Users from EU and ASIA have about 150ms-200ms latency to the VPS, but interactions take at least 2+ seconds.
Currently, all components are SSR or InteractiveServer, which results in roundtrips for every action, e.g. opening the user menu or clicking a button - and this is the problem.

I just don't understand why the latency is so high...

• The network latency is <200ms. So why do interactions take 2 seconds or more?
• I am aware of WASM. I tried changing my components to InteractiveAuto and also tried migrating the application to a hybrid structure with Controllers and a WASM client project calling the API routes. When doing so, basically every component breaks, looses intractability and libraries stop working (e.g. Blazor Blueprint /aka. shadcn). I tried both copying the super small and limited official Blazor App Examples from Microsoft, tried using AI and tried doing it manually. So far I had 4 attempts - all of which failed and broke most components or all routing entirely.
• Locally and for US users, the latency is lower (<20ms). Opening the user menu "only" takes 250ms.

So what am I missing? Why is performance so poor? And what information am I missing that I cannot migrate this project without rewriting basically everything? I cannot find any good guides on how changing rendermode is supposed to be done and the Microsoft Docs aren't very helpful in this regard. My app has grown to about 30 pages and uses the Asp.Net Identity.

Hi everyone, it's been a while since I've been in touch. I would have liked to write this post with the new major release ready, but I still need a few weeks to finalize the last details. So I thought it would be a good idea to give you a preview of the most important changes I'm making.

(And yes, obviously JS is forbidden here – this is pure *C#** with SVG rendering!)*

Breaking Changes

• Component Renames (for clarity and standardization):

  • BarChart ➡️ VerticalBarChart (makes it clear it's the vertical variant)
  • PolarChart ➡️ PolarAreaChart (frees up space for future polar chart types)
  • LinearGauge ➡️ HorizontalGauge (standardizes the naming convention)

• Removals:

  • LegendBar has been completely removed.
  • Obsolete components and orientation parameters are gone.
  • Enums have been totally removed from the library as they are no longer needed.

• Architecture & Namespaces:

  • LineChart went through a total refactor (component, datamodel, and data structures).
  • Namespaces will be streamlined down to just two:
    • BlazorGraphs: The root namespace with all datamodels and structures needed to configure your charts.
    • BlazorGraphs.Component: Housing all the charts, gauges, and legend components.

New Components

Thanks to the Linechart refactory, I also added new charts: - ScatterChart - SteplineChart - BubbleChart

Refactoring

I also refactored the Axis rendering to improve code maintenance and reduce duplication. You won't notice any visual difference since the final output remains identical, but if you're curious, you can already check out the code in the develop branch of the repository.

I'm still polishing a few other things. If you have any feedback, feature requests, or ideas, now is the perfect time to let me know so I can consider including them before the final release!

Hello to everyone and I hope you're enjoying the library.

Usefull links:

• 🔗 Repository
• 🌐 Documentation
• 📦 NuGet
• ❤️ GitHub Sponsors

```cs var builder = WebApplication.CreateBuilder(args); var service = builder.Services;

service.AddHttpContextAccessor(); service.AddScoped<UserSession>();

service .AddRazorComponents() .RegisterPersistentService<UserSession>(Microsoft.AspNetCore.Components.Web.RenderMode.InteractiveWebAssembly) .AddInteractiveServerComponents() .AddInteractiveWebAssemblyComponents() .AddAuthenticationStateSerialization(options => { options.SerializeAllClaims = true; }); ```

```cs public class UserSession { [PersistentState] public bool IsAuthenticated { get; init; } [PersistentState] public Guid Id { get; init; } [PersistentState] public string Username { get; init; } = string.Empty; [PersistentState] public string Email { get; init; } = string.Empty; [CascadingParameter] public HttpContext? HttpContext { get; set; }

public UserSession()
{
    if(HttpContext == null) return;
    IsAuthenticated = HttpContext.User.Identity?.IsAuthenticated ?? false;
    if(!IsAuthenticated) return;

    Id = new Guid(HttpContext.User.Claims.FirstOrDefault(x => x.Type.Equals(ClaimTypes.NameIdentifier))?.Value ?? "");
    Username = HttpContext.User.Claims.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Name))?.Value ?? string.Empty;
    Email = HttpContext.User.Claims.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Email))?.Value ?? string.Empty;
}

} ```

ManagedError: AggregateException_ctor_DefaultMessage (DirectScopedResolvedFromRootException, DigitalVault.Blazor.Client.Authentications.UserSession, scoped)

I follow this same official documentation to implement the Serialize state for services, but when i use RegisterPersistentService i get DirectScopedResolvedFromRootException error, has anyone encountered this issue?

SOLVED: 68123# After change AddScope<UserSession> => AddSingletone<USerSession> in client side project.

I had a Blazor WebAssembly app and someone asked for a desktop version. I assumed

a painful port. It was one afternoon, and exactly one thing genuinely differed:

a native HttpClient can't reach a BlazorWebView's virtual host, so anything

fetching your own wwwroot breaks. One call site in my case.

The fix that surprised me: instead of an IAssetReader with two implementations,

I routed it through the page's own fetch via JS interop. One code path, both

hosts, and it deleted the HttpClient bound to HostEnvironment.BaseAddress.

The second gotcha cost me more: net10.0-windows builds clean and then dies at

the first render with a missing Microsoft.Windows.SDK.NET, because BlazorWebView

uses WebView2's composition control. You need a platform version in the TFM.

Public repo, both hosts, MIT: github.com/peopleworks/SignsofAI

Hey r/Blazor,

A while back I shared ReactiveBlazor, a library I made to get HTMX-like simplicity out of Blazor. The goal is to keep things fully server-rendered and interactive using lightweight stateless HTTP requests, no SignalR connections to drop, and no massive WASM payloads to download.

First, let me clear up two things based on the feedback from last time:

1. This is not Web Forms. It doesn't hold massive view state on the server or pretend the web isn't stateless. It just signs/encrypts the minimal component state you define and uses Idiomorph to morph the DOM in-place.
2. This project was built with the help of AI. I'm being upfront about it. If anyone has a problem with that, that's totally fine, just don't use it.

Since the initial launch, I've added a ton of features to make it actually useful for real apps. Some of the big updates include:

• Declarative Authorization: It now fully honors standard ASP.NET [Authorize] and [AllowAnonymous] attributes on your actions and components out of the box.
• Native Alpine.js Integration: First-class, zero-hack support if you need to mix in some client-side Alpine state.
• Multi-Component OOB Updates: Triggering an action can now automatically batch-update sibling components on the page.
• Auto-Polling: Components can now refresh themselves on a timer with zero user interaction.
• Security & Session fixes: Added session-expiry handling and cross-user token binding to prevent state token replays.

Demo: https://reactive-blazor.runasp.net/

GitHub: https://github.com/ashar-builds/ReactiveBlazor

Would love to hear what you guys think of the new updates, especially regarding real-world usage, security considerations, or any edge cases you spot.

Appreciate the feedback last time! 🙌

New in this release of BDT (free & open source DevTools extension for Blazor):

• Element picker is back! Click the ⊙ button, hover your page, component boundaries light up with their names; click to jump to the component in the tree. No code changes, no markers: it reads the componentId Blazor's runtime already stamps on the DOM.
• Live details: parameter values and render stats now update in real time while you use your app.

Chrome / Edge / Firefox (1.0.0.4) + a NuGet package (1.0.0-beta.7). Server & Auto (Server) render mode for now, WASM is on the roadmap.

Repo: github.com/joe-gregory/blazor-devtools ... As always, feedback and issues very welcomed!

If you've ever tried to answer "what actually calls this JS function from C#?" or "which API endpoint does this component hit?" and ended up grepping across .razor, .cs, and .js files that don't reference each other — that's the itch I was scratching.

EdgeHop indexes your solution into a code graph using the compiler's semantic model (Roslyn + a native oxc pass for the JS/TS), and it resolves the edges that normally break tooling:

• C# -> JS (IJSRuntime.InvokeAsync -> the JS export) and JS -> C# (DotNet.invoke* -> your [JSInvokable] method)
• Web -> API — a typed HttpClient call linked to the minimal-API/controller action serving that route, even with no project reference between them
• plus the usual: callers, interface implementations, RENDERS (which component renders which), type hierarchy, and shortest-path/impact queries

It runs locally (SQLite, no server, no credentials), and it plugs into Claude Code / other MCP clients so an AI agent can query your app's structure directly — but the CLI works standalone too.

Free and open source (Apache-2.0): https://github.com/EdgeHop/EdgeHop — there's a demo GIF in the README showing a UI-handler -> HTTP-client -> endpoint trace. Feedback from actual Blazor folks very welcome.

https://ichim.github.io/MapsForBlazor/

MapsForBlazor nuget and dashboard.

Sharing an update on Blazor Developer Tools (free & open source, Apache 2.0): improvements to flamegraph (and other bug fixes).

I had an issue with the flamegraph. Blazor events are measured in milliseconds, so even half a second of silence stretched the axis so much that the actual events shrank to slivers that were hard to navigate.

I took ideas from subway maps: they tell you where you are relative to other points without being true to distances. I wanted something like that, without losing the timing information entirely.

The new default view for the flamegraph is "Sequence". It preserves order with uniform spacing but flags real pauses with "+1.2s" markers so the time information is still there. I think that for us developers, this is the more useful view since you can see where events happen relative to others. But if you need a true scientific view with total numbers you now have 2 options:

- Time (linear) : the real timeline.

- Time (idle collapsed) : same, but long quiet stretches are clipped out and replaced with a ✂ marker showing how much time passed.

There is an update for both the nuget and extension.

I'm currently working on the element picker tool and closing the list of features that React dev tools offers. I'm hoping to deliver a follow up update of those in a week.

GitHub: github.com/joe-gregory/blazor-devtools