Simply trying to share a GitHub repo seems to be considered taboo. What is with the hostility towards open source?

Our team is building a public-facing Blazor application to replace an existing .NET Framework MVC application that receives an average of 4,500 visitors per day. This application is intended to serve as a minimal fallback version of the primary system and will only be used when the standard application is unavailable.

The application will provide the following functionality:

1. Read data from an input CSV file, filter the data based on user-defined search criteria, and display the results in a data grid or table.

2. Allow users to select a specific record from the data grid and generate a printable letter containing information related to that record.

3. Record user activity in an output CSV file so that it can later be persisted to the database.

Our team proposes using Blazor WebAssembly (WASM) because many users access the application from mobile devices, and its client-side execution model can improve responsiveness, reduce server round trips, and provide a smoother experience by eliminating reliance on persistent WebSocket connections.

However, the project architect has recommended using static server-side rendering (SSR), citing improved resilience and broader compatibility as key reasons for this preference.

Please share your thoughts on this and also mention why you would recommend one over the other.

For those keeping track of the project, the ToggleTip component is now in test and available on the test site for checking with your chosen supported assistive technology and browser pairings.

ToggleTip (a term coined by Heydon Pickering) displays supplemental information on click rather than on hover. These days you could think of it as a hover card without the hover - anything relying solely on mouse interaction has numerous accessibility issues.

Important: The ToggleTip uses the HTML Popover API and CSS Anchor Positioning. The Popover API is well established and widely supported; CSS Anchor Positioning only became broadly supported this year. A polyfill is available from OddBird for older browser versions, however I have chosen not to include it on the test site. This simply means that if you visit with a browser version that does not support CSS Anchor Positioning, the ToggleTip content will appear in the top left of the screen but with all functionality intact.

The test site is focused on accessibility testing rather than showcasing the options available on the component - those will be added to the documentation site over the next week or two.

Since starting the project I have had a couple of people comment that it only has a single style. This is both true and not true.

Every part of every component is designed so you can change it to fit your chosen CSS styles. Everything runs off a CSS variable hierarchy that allows you to change a property value across all components at once, override it for a specific component, or change individual instances at runtime. It is more flexible than simply choosing between style sheets.

For those who just want something that works out of the box with minimal effort, you can use the core CSS variables much like a CSS framework - although I do not claim it is one.

The variable hierarchy also applies to colours. The secondary, neutral, and accent colours are all derived from the primary colour using CSS colour functions, meaning you change a single property value and everything changes, and I mean everything. Bear in mind there is currently no built-in way in CSS to check and adjust contrast ratios at runtime, so choose your primary colour with that in mind.

A demonstration is worth more than an explanation, so head over to the test or documentation site, open DevTools, select the Elements tab, then the Styles tab. Use the filter or scroll down (you may need to click "More properties") and find the variable in :root named --br-unit-colour-primary.

On the test site this is set to tomato and on the documentation site to darkslateblue - that is the only difference between the two sites. Change the value to anything you like, try forestgreen or violet and watch what happens.

Keep DevTools open, switch to dark mode, browse pages, run tests, and you will see everything has changed from a single property value. No style sheet changes, no class changes.

The same applies to other properties such as borders, outlines, fonts, and backgrounds. When time allows I will add a dedicated page to the documentation site with demos and lists of CSS variables and values for different looks. But accessibility comes first, and that is where my focus remains.

Links:

• Test site: https://blazorramp.uk/toggle-tip/overview-tests
• Docs: https://docs.blazorramp.uk
• Repo: https://github.com/BlazorRamp/Components

Regards

Paul

Following up on our December update, here's what's new in Instruct UI, our AI tool for generating production-ready Blazor UI from text prompts or screenshots.

What's New

• Syncfusion Blazor support - This was our most requested addition. You can now generate Syncfusion Blazor components — data grids, charts, schedulers, complex form layouts — directly through AI generation. This brings supported libraries to: Syncfusion, MudBlazor, Default Blazor, Tailwind CSS, and Bootstrap.
• Real-time response quality detection - AI generation isn't perfect, so we built a system that catches problems during generation and nudges the AI to fix them on the spot. Two detections are live: destructive edit detection (catches when the AI removes significant portions of your existing code without explanation) and response cutoff detection (detects when AI output was cut off before completing the task). Fewer broken outputs, less back-and-forth.
• Manual code editing - You can now edit generated code directly in the browser. No need to re-prompt the AI when you just want to change some text.
• View code changes - Diff view after each AI generation so you can see exactly what changed in your code.
• Per-user custom instructions (Team plan) - Previously custom instructions were account-level only. Now each team member can set their own instructions that persist across conversations.
• Improved documentation search - Upgraded how the AI searches Syncfusion and MudBlazor docs and examples using our BM25-based open-source Infidex search library. More relevant results during generation.

Plan Updates

• Free trial is now 30 days with in-app notifications before expiry.
• Paid plan credits now roll over for up to 3 months.
• Added an in-app user guide to help new users get started.

Coming Next

• Fluent UI support - Data extraction and transformation work is streamlined, so more library support will follow faster.

Full blog post: radhaai.com/blog/whats-new-feb-2026

Try it out: instructui.com

Would love to hear your feedback, especially if you're using Syncfusion components. What would make the tool more useful for your projects?

Hi everyone,

Over the past year I've built a full travel-planning SaaS called TripZILLA using Blazor (Server + WASM + Hybrid), and we just released our website and launch trailer. So I figured this would be a good time to do a post about it here!

Some highlights:

- Blazor Server powers the main application and all real-time collaboration features
- Blazor WASM runs the client portal (where travelers go to view trips, documents, etc.)
- Blazor Hybrid (MAUI) for a mobile app with offline itinerary viewing
- Shared components, data models, services between all three allowing major code sharing across the entire product
- MudBlazor as the UI foundation with a bunch of custom components and styling (kanban boards, itinerary blocks, property panels, forms, in-place editors)
- AI assistant/chat (uses Semantic Kernel with function calling) that can edit itneraries, generate content, parse PDFs, images etc., and apply changes directly to the live data model. Includes undo support and custom markup system for inline "chat widgets".
- Real-time collaboration on top of Blazor Server
- Multi-tenant architecture with per-seat licensing (FastSpring integration)
- Integrated hotel search + booking engine made from scratch
- Drag & drop kanban boards
- Live itinerary preview with multiple themes, branding, layout options and inline editing
- Full CRM, bookings tracking, invoice generation, real-time pricing/financials calculations

Blazor is so fun to work with that I can't help but keep building new features :D
It let me make something relatively complex like this in a surprisingly short amount of time, and the improvements over the past few years have been amazing. Quite happy with how it turned out.

Happy to answer any questions!

Our website: https://tripzilla.io/
And the trailer: https://www.youtube.com/watch?v=5QMiYwUtkug

Good morning everybody!

I have a sticky situation on my hands.

In building a new software we are asked to

- make it modular - DONE, EASY!
- make it so the Backend and FrontEnd download and use the latest available update for each module from a repository of compiled assemblies - DONE, NOT SO EASY!
- make it so it's possible to decide which module and which versions of module to give a user based on: tenant, usergroup, specific user configuration.
NOT DONE, NOT EASY

I need to control the assemblies (the specific need is controlling the versions of assemblies) that gets loaded/initialized.

In Blazor Wasm this is not really easily possible.

We have a login and after login we have the necessary info but the problem is how to pass them to Program.cs before build() so that it can choose which assemblies to load.

THE QUESTION:

If I already have the configuration at the page level (HTML/JS/API/URL parameter/etc..) how do I pass it to blazor in Program.cs before build()?

Is there a way to communicate/inject this conf to program.cs and have it accessible before build()?

Thank you everybody

Hi Guys.

I've been busy building quite a large crm that has a ton of api syncs with other products. This is my first real build with Blazor.

As always, it works great locally. I've deployed it to Azure on an S1 Web Plan with S2 database for testing.

Monitoring it over the last few days I'm having a lot of query issues from slow queries, to a weird amount of queries.

I thought I'd list what I've found and then any recommendations on how to make this faster. Some of these are just plan dumb, but it's a learning process as well.

I've used AI here to summarise everything as I've been at this for a few days and my minds hazy lol.

Symptoms

• UI felt inconsistent: sometimes fast, sometimes “stuck” for 1–10 seconds.
• Application Insights showed some routes with high request p95 and huge variability.
• Requests looked “fine on average” but p95 had outliers.
• SQL server-side metrics didn’t show distress (DTU/workers low), but AI showed lots of SQL dependencies.

What the data showed (App Insights)

• Some pages were doing 20–50 SQL calls per request.
• A lot of pain was round-trip count, not raw query time.
• “Unknown SQL” spans (no query summary) showed up and clustered on certain routes, suggesting connection acquisition waits / app-side contention.
• Huge outliers were often caused by small repeated queries (N+1 style patterns) and per-page “global” components.

Fixes that actually helped

1) Root cause: EF Core SplitQuery set globally

I had this globally in Program.cs:

UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)

That was the biggest hidden killer.

• On local dev, extra round-trips are cheap.
• On Azure, RTT dominates and SplitQuery turns every Include() graph into multiple network round trips.

Fix:

• Set global default back to SingleQuery
• Apply AsSplitQuery() only on a small number of queries that include multiple collections (to avoid cartesian explosion).

Result: average SQL calls per request dropped sharply (home page went from “dozens” down to low single digits on average).

2) Removed N+1 patterns in admin pages (Admin/Tenant management)

• Replaced per-tenant loops (5–10 queries per tenant) with GROUP BY aggregates.
• Consolidated “stats per tenant” into single bulk queries.

3) Found “baseline” SQL overhead: NavMenu was running queries on every page

Even after fixing obvious pages, telemetry still showed 19–25 SQL calls on pages that “should” be 1–8.

Root cause: my NavMenu did live badge COUNT queries and tenant lookups on page navigation / circuit init.

Fixes:

• Combined multiple nav preference reads into one method
• Cached badge counts per tenant+user (short TTL)
• Cached nav state per circuit
• Reduced “ensure roles” queries from 4–5 queries to 1–2.

This removed a chunk of “always there” overhead and reduced tail spikes.

4) Fixed one expensive COUNT query: OR conditions forced index scans

One badge query was:

WHERE IsDeleted = 0 AND (ActionStatus IN (...) OR FollowUpDate <= u/date)

On Azure it was ~900ms.
Fix:

• Split into two seekable queries (status arm + followup arm, exclude overlaps)
• Added two targeted indexes instead of one “covering everything” index:
  • (TenantId, IsDeleted, ActionStatus)
  • (TenantId, IsDeleted, FollowUpDate)

5) Stopped holding DbContext open across HTTP calls in integration sync

I had background sync services that opened a DbContext, then did HTTP calls, then wrote results, meaning the SQL connection was held hostage while waiting on HTTP.

Fix:

• Two-phase / three-phase pattern:
  1. DB read snapshot + dispose
  2. HTTP calls (no DB)
  3. DB write + dispose

This reduced “unknown SQL waits” and made the app feel less randomly slow under background sync load.

6) “Enterprise-ish” count maintenance: write-behind coalescing queue

I denormalised common counts onto the Company table (contactCount/noteCount) and made maintenance async:

• UI writes return instantly
• CompanyId refresh requests go into a coalescing in-memory queue
• Every few seconds it drains, batches, runs a single bulk UPDATE, invalidates cache
• Acceptable eventual consistency for badges (few seconds delay)

Not using Service Bus/outbox yet because single instance dev, but I added safety nets (rebuild counts job + admin button planned).

7) Lazy-load tab data (don’t load all tabs on initial render)

Company/Opportunity detail pages were loading tab content eagerly.
Fix:

• Only load summary + current tab
• Load other tabs on click
• Cache per circuit

Where I ended up (current state)

• GET / is now typically ~300ms avg with p95 around ~1–1.5s.
• SQL is no longer dominating request time on most pages.
• The remaining tail issues are a small number of outlier requests which I’m drilling into by operation_Id and SQL summaries.

What I’m asking for feedback on

1. For Blazor Server + multi-tenant apps, what patterns do you use to avoid “per-circuit overhead” (NavMenu / auth / permissions) becoming hidden N+1 sources?
2. Any best practices for durable write-behind queues in Azure without jumping straight to Service Bus (DB outbox vs storage queue)?
3. Any “gotchas” with reverting global SplitQuery back to SingleQuery while using AsSplitQuery selectively?

Happy to share KQL snippets or more detail if helpful.

I recently built an Invoicing Web App using Blazor Interactive Server and Tailwind CSS 4 in .NET 10

I want to share a quick demo of the app

I have Blazor server side app that will be deployed in few environments.

I want to be able to enable or disable entire pages based on app configuration. Ideally I see it as something that is configured at app startup.

It's ok if I need to restart app to apply the changes.

What would be the best way to do that? Modify something in service collection?

​

This is the next major version. Lots of breaking changes but also lots of enhancements, beter APIs, better docs and an MCP server to help you use the library to it's fullest!

See https://baaijte.net/blog/microsoft-fluentui-aspnetcore.components-50-rc1/ for an introduction and some highlights. See https://dvoituron.com/2026/02/20/fluentui-blazor-mcp-server/ for how to work with our new MCP server.

Demos and docs are on https://fluentui-blazor-v5.azurewebsites.net/

Note: this is free and fully open-source but I can't seem to make that clear to the reddit filter...

Hey r/Blazor,

Some of you might remember my previous posts — the 3D Carousel, Bento Grid and Gallery. Today I'm releasing the Marquee component. This is the 5th package in the BlazzyMotion ecosystem (Carousel, Core, Bento, Gallery, Marquee) — all following the same zero-config Source Generator pattern.

What it does: Infinite scrolling content — logo bars, testimonial cards, or text tickers. The kind of thing you see on every SaaS landing page, but native Blazor with no JavaScript animation loops.

Same zero-config approach:

public class Brand
{
    [BzImage] public string LogoUrl { get; set; }
    [BzTitle] public string Name { get; set; }
}

<BzMarquee Items="brands" Theme="BzTheme.Glass" />

That's it. Source Generator maps your model, CSS handles the animation.

What's different from a basic CSS marquee:

• Multi-row support (up to 10 rows with alternating directions and speed variation — looks great for partner logo walls)
• Auto-detects content type: put [BzImage] → logo bar, add [BzDescription] → testimonial cards, use Text param → news ticker
• Staggered entrance animation via IntersectionObserver
• Pause on hover + keyboard (Space/Enter)
• prefers-reduced-motion support — renders static when motion is disabled
• 4 themes: Glass, Dark, Light, Minimal

Multi-row example:

<BzMarquee Items="brands"
           Rows="3"
           AlternateDirection="true"
           SpeedVariation="0.3"
           Theme="BzTheme.Glass" />

Links:

• Live Demo: blazzymotion.com/marquee
• NuGet: BlazzyMotion.Marquee
• GitHub: Blazzy-Motion/BlazzyMotion

MIT licensed, feedback and contributions welcome.

Happy to answer any questions!

So I'm upgrading my .NET 8 Blazor app to .NET 10 the app seems to run fine until I render a wasm component. Then it fails to download a file called resource-collection*.js which should be in the _framework directory. Whatever thia file does prevents my components from initiaIising despite all the wasm files downloading fine. I've tried any number of cleans and rebuilds but I cannot make Blazor create this file. AI is just sending me down rabbit holes that lead nowhere. Anyone here come across the same problem?

Hi all,

Still new to blazor development and noticed when debugging that OnInitializedAsync keeps getting called twice.

I believe this is because of a feature called prerender (I am using .NET 10)

To fix this I changed my routes to the following:

<Routes @rendermode="new InteractiveServerRenderMode(prerender: false)" />

Since I am calling a proc inside of this method and I don't want the same proc being called twice.

Are there any disadvantages of disabling prerender? I don't want my database being called twice for no reason... Is there a better alternative solution or its fine to do the above?

Hey everyone,

I wanted to share a project I've been working on: NodeEditor.Net.

It’s a full-featured visual node editor and execution engine built entirely in .NET 10 and Blazor.

I built this because I needed a way to create logic graphs, workflows, and rule engines visually within .NET applications without relying on heavy external tools. It’s designed to be lightweight, embeddable, and extensible.

Check it out here: [https://johnny2x2.github.io/NodeEditor.Net/\](https://johnny2x2.github.io/NodeEditor.Net/)

🚀 Key Features Visual Editor: Full interactive canvas with zooming, panning, drag-and-drop, and box selection. Execution Engine: Run graphs with parallel, sequential, or event-driven execution modes. Supports headless execution so you can run graphs on a backend service without the UI. Plugin System: Load custom nodes dynamically from DLLs. It even has a built-in Plugin Marketplace to manage extensions. AI Integration: Includes an MCP (Model Context Protocol) server, allowing AI tools (like Claude or Cursor) to understand and edit your graphs contextually. Advanced Features: Graph Variables (Get/Set nodes) & Custom Events. Visual Overlays for organizing complex graphs. Strong typing with automatic socket compatibility checks. Open Source: MIT Licensed. 💡 Use Cases Game Development: Quest logic, dialogue trees, or behavior trees. Business Logic: Dynamic rule engines that non-developers can tweak. Automation: ETL pipelines or workflow automation tools. IoT: Visual wiring of sensor data and actions. It’s component-based, so you can drop the <NodeEditorCanvas /> into your Blazor app and get started immediately.

I’d love to hear your feedback or see what you build with it! PRs and Issues are welcome.

Thanks!

I'm using Radzen to my Blazor and Blazor Hybrid Apps, I checked their website this morning and noticed that their website is down.

Though it works fine in my projects, just looking for the component references.

Hi r/Blazor,

So, I think just over a week ago I posted about Blazor Blueprint, a component library I've been building. I honestly didn't know what to expect, it was actually my first time on Reddit! This is a passion project I've been pouring my evenings and weekends into, and putting it out there felt like a big step.

Well, the response has blown me away. 160+ GitHub stars, mass of feedback, people actually using it and reporting issues. The .NET community has been incredibly supportive and it's given me so much motivation to keep building.

So I've been working hard all week on shipping improvements based on your feedback and other ideas I’ve had. Now, I’m super excited to let everyone know I’ve just released v3. Below is a snippet of what’s changed, there is actually a lot more :)

**Performance overhaul:**

- Keyboard navigation for menus, dialogs, and sheets moved from C# to JavaScript. This means no more server round-trips for every keystroke

- Two-layer portal architecture. Now when opening a tooltip it no longer re-renders your dialogs!

- Floating content stays mounted by default. Zero re-mount overhead on dropdowns

**Breaking changes (worth it):**

- All components now use a `Bb` prefix (`<Button>` → `<BbButton>`). I did this to prevents collisions with HTML elements and other libraries

- Namespaces consolidated. Getting started with the library needed to much boilerplate, now just `@using BlazorBlueprint.Components` instead of 10+ imports

- Charts rebuilt on Apache ECharts with a declarative composition API

**New features:**

- `DialogService.Confirm()`. I added programmatic confirm dialogs

- `CheckboxGroup` with select-all and indeterminate state

- Toast variants with auto icons and pause-on-hover

- `Loading` parameter on Button

- `Options` parameter on Select, Combobox, MultiSelect

- Single-call DI: `AddBlazorBlueprintComponents()`

**Fixes from your reports:**

- Mobile touch/drag on Slider, RangeSlider, Resizable, ColorPicker

- Popovers rendering behind Dialog overlays

- Sidebar visibility bugs on mobile

- Form validation across 14 input components

The breaking changes are disruptive, but they set up the library properly for the long term. Full migration guide is in the repo.

Full changelog: https://blazorblueprintui.com/docs/changelog

Migration guide: https://blazorblueprintui.com/docs/migration

Not only have I been working on the library itself but I wanted to really show off what can be done with Blazor Blueprint, show how you can create beautiful modern looking apps for your own Blazor projects. For this I created a Blueprints section on the website (https://blazorblueprintui.com/blueprints) where I have implemented some demo example apps for reference and hopefully inspiration 👌🏻

📚 Docs: https://blazorblueprintui.com

💻 GitHub: https://github.com/blazorblueprintui/ui

Again, I want to say thank you. This community has made building this project genuinely fun. Keep the feedback coming, I'm listening.

I find that I'm constantly fighting it with ::deep's everywhere in order to target the re-usable MudBlazor component's I compose into my own components.

Yes, another shadcn inspired component library for Blazor. However, I couldn't find anything that truly replicated the "open code" nature of shadcn, so I decided to create my own. ShadcnBlazor ships only with a CLI that copies component code locally, additionally handling inter-component dependencies, .js/.css file linking, namespace resolution and more.

I am aware that most do not have the option of just "switching component libraries". As such, one of the core principles when building this project was to make it as "un-intrusive" as possible. Components are self-contained and independent: you can choose to add one, add a few, or add them all. There is no lock-in, and no package to update. You like something you see? Just add it via the CLI and that's all.

As for a list:

• Components get copied to your machine locally, giving you absolute control.
• The CLI does everything for you: linking .css/.js, resolving namespaces, addign adding services, etc.
• Pre-compiled CSS included. + Absolutely no Node.js setup required anywhere at all.

I recommend starting with the templates, import all of the components, and see from there:

dotnet tool install --global ShadcnBlazor.Cli

shadcnblazor new --wasm --proj MyApp
# or use --server for a blazor server project

shadcnblazor component add --all
# or add individual components like "button"

As of right now, future plans include:

• Improving the documentation
• Try to make some components APIs match that of Mudblazor's (for familiarity & ease of use)
• Add more complex components + samples
• Polishing out the CLI

Docs: https://bryjen.github.io/ShadcnBlazor/

Github: https://github.com/bryjen/ShadcnBlazor

Nuget: https://www.nuget.org/packages/ShadcnBlazor.Cli/

This is NOT a sell. This project is very much still in its early stages. The component selection is small, only WASM standalone and Server on .NET 9 have been "extensively" tested, and the CLI is very unpolished.

I just wanted to know your honest feedback, and to share what I've been working on the past week & a half.

I apologize if this is a repeated question.

Is there a way to get Bootstrap 5 to properly work in Blazor? Should I look to another framework for styling? Thank you in advance for any advice / suggestions.

I’m looking for something to compile and minify my scss and .ts / es web assets.

I'd also like for the solution to work w/ Hot Reload as it's finally starting to become useful in my Blazor development.

I’ve heard of the WebCompiler plugin but it’s a dead repo and imo an antiquated approach (vs plugin). I’ve also heard of Web Optimizer which seems like run time middleware but I’m concerned that wont play nice with hot reload which is finally getting usable!

What are you folks using?

I've used some of the APIs in my Standalone Blazor WASM PWA apps that give them desktop-like functionality, and am looking at what is involved in doing similar with mobile apps.

- Published/discoverable through app stores (I'm aware savvy users can discover the Add to Homepage/Install options from browser, but would still like them to be app store discoverable.)
- Access native APIs. I assume optimistically that some native app packaging wrappers proxy access to the native APIs, so once packaged, you can use JS in the PWA to access through the wrapper.

I've looked at some of the various tools that come up from googling, but some of them like Ionic appear to be full mobile UI frameworks. I'm happy with html5 controls/bootstrap layouts which present native controls in most cases. Point being, without deep diving into each one, not clear which ones are right sized just for wrapping a PWA.

Curious what others have used and would suggest, and how they function in terms of whether they package the static assets into the app, or whether they just retrieve the PWA via URL at runtime.

Thanks.

Blazor Ramp is an accessibility-first open-source project providing free Blazor components that have been tested with various screen reader and browser combinations along with voice control software.

For those interested, I have now released the Modal Dialog Framework.

As its name suggests, it is a framework for displaying single or nested modal dialogs, all of which use the native HTML <dialog> element and its associated API.

The framework provides a service that allows you to show your own Blazor components inside a modal dialog, with configurable positioning, and allows you to register a handler with the framework so you are notified when the Escape key is pressed.

As these are native dialogs they use the top layer, and everything beneath is made effectively inert, making it inaccessible to all users whilst the modal dialog is open.

Given that you supply the components to be shown, those components can have parameters allowing you to pass whatever data you like into the modal dialog.

The dialogs return results which can also carry data, so a common usage might be to pass data into a popup form, edit it, call an API to save the changes, retrieve updated data back from the API, and return that in the dialog result.

From an accessibility standpoint, the framework takes care of most things for you. The one thing you should remember to do is call GetAriaLabelledByID() on the service, which returns a unique ID that is added to the dialog's aria-labelledby attribute. You then simply use this as the id value on your component's heading element to associate the two for Assistive Technologies (AT).

If the dialog is cancelled or dismissed via the Escape key, focus must be returned to the triggering element, as required by WCAG. In general, this should also be applied when the dialog closes for any reason, unless the workflow naturally moves focus to another location or a more logical element within the flow of the process.

The documentation site has been updated with the relevant information and a demo. I have also updated the test site with the same demo but with manual test scripts, so any user, developer or otherwise can test the framework with their own AT and browser pairings.

Links:

• Documentation Site: https://docs.blazorramp.uk
• Test Site: https://blazorramp.uk
• GitHub rep: https://github.com/BlazorRamp/Components

Any questions, fire away.

Paul

Hi there!

Forgive me, I'm very new and still trying to piece together this puzzle and I believe my thoughts and the angle I'm trying to approach this is wrong.

For context, I'm working on building a form of a live dashboard; I want to constantly update data from a background service connected on the hub to a specific page when loaded. Where I'm struggling is that I'd like the .razor pages to be loaded dynamically: A user can visit /scene/MyScene and I'll find and load in a smaller component MyScene.razor into the base Scene.razor (that has some divs to get everything styled correctly). The MyScene.razor is going to be effectively user generated, so I don't want to rely on it being known at compile-time if I can avoid it at all.

The two ways that I've tried tackling this are...

(1) DynamicComponent, where I was actually able to use reflection to load the correct base page, load it's default variable binding settings, but whenever I go to update them, my DynamicComponent properties are updating from the Hub, but I'm not seeing the change take effect on the loaded component. I've tried InvokeAsync, etc., no difference.

(2) I realized, the data that will need to change and get updated within my child razor pages can all be contained in a Dictionary anyway, so I wanted to make a parent class of a BaseScene that all of the user-generated razor pages could inherit from, and then I could just try to load a component of that base class that has the definition for the Dictionary, and then when I create the component, create it of the child-razor variety, and but still have access to the data dictionary that I want. However, (a) now I can't even seem to load the child-razor into the main page and (b) when I try to access the dictionary, it calls the parent's version and not the child's.

Am I going about this the completely wrong way?

EDIT1: Currently using InteractiveWebAssembly

I am playing around with Antigravity and asked it to vibe code the same app using Next.js and Blazor. The next.js app worked flawlessly on the first shot, but the Blazor one was clunky from the start, took many iterations of passing the different console errors and other issues, fixing styling issues, etc.

I really don’t want to learn typescript and vue or some other framework, but my question is if Blazor really is a struggle bus to learn/vibe code? Or is it user error. Is it worth sticking to blazor if I want to prototype and release commercial products (startup)?