Skip to content
CAI
Software that uses CAICheck a score

slaveOftime/Fun.Blazor

39.0

Weak · 13 November 2026

42.9k

lines of production code

F#

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Blazor component benchmarks for performance comparison

The benchmark suite now includes new test cases to compare the rendering performance of Blazor components implemented in C\# against those written in F\# using the Fun.Blazor library. Specifically, it adds benchmarks for a standard C\# Razor component, a Bolero component, and three Fun.Blazor variants (inline computation expressions, array-based child content, and template-based rendering), allowing users to evaluate the overhead of different component implementation strategies.

Benchmark · high confidence

Add Fun.Blazor.Diagrams binding for Blazor diagramming DSL

This change introduces a new F\# binding for the Blazor.Diagrams library, enabling users to define diagram layouts using a declarative DSL. The binding exposes builders for core diagram elements such as nodes, links, groups, and ports, as well as UI widgets like the grid, navigator, and selection box. It also includes renderers for visualizing these elements and controls for interactions like dragging new links or removing items. An ILLink.Substitutions.xml file is added to optimize the final application size by removing unnecessary F\# signature and optimization data during trimming.

Bindings/Fun.Blazor.Diagrams · high confidence

Add documentation server with Custom Elements and htmx demos

The Fun.Blazor.Docs.Server project now includes a complete documentation site featuring interactive demos for Custom Elements and htmx integration. Users can explore Custom Elements with various rendering modes (prerender, lazy load by click/viewport/delay) and htmx features including Server-Sent Events (SSE) for stock updates and SSR-based interactions. The server is configured to register custom elements by assembly and supports both interactive server and WebAssembly render modes.

Fun.Blazor.Docs.Server · high confidence

Added Brotli decompression support for documentation assets

The documentation site now includes a client-side JavaScript module (\decode.min.js\) capable of decompressing Brotli-compressed content. This enables the delivery of smaller, compressed documentation files to the browser, which are then decoded on the client side to improve load performance.

Fun.Blazor.Docs.Wasm/wwwroot · high confidence

Added F\# DSL bindings for Microsoft.AspNetCore.Components.QuickGrid

This change introduces a new F\# binding library for the Microsoft.AspNetCore.Components.QuickGrid Blazor component. It provides a domain-specific language (DSL) via computation expressions, allowing users to define QuickGrid instances, PropertyColumns, TemplateColumns, and Paginator components using F\#-friendly syntax. The bindings expose key features such as data virtualization (Virtualize, ItemSize, OverscanCount), pagination (Pagination, Paginator), sorting (Sortable, InitialSortDirection), and theming. An ILLink.Substitutions.xml file is also included to optimize the resulting assembly size by removing F\# signature and optimization compressed data during trimming.

Bindings/Fun.Blazor.Microsoft.QuickGrid · high confidence

Added F\# bindings for AuthorizeRouteView component

This change introduces a new binding for the \Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView\ component within the \Fun.Blazor.Microsoft.Authorization\ library. The \Bindings.fs\ file defines a \AuthorizeRouteView'\ type that exposes key parameters such as \RouteData\, \DefaultLayout\, \NotAuthorized\, \Authorizing\, and \Resource\ via custom operations, allowing users to integrate authorization logic into their Blazor routing. Additionally, an \ILLink.Substitutions.xml\ file is included to configure the linker to remove specific F\# signature and optimization compressed data resources, ensuring proper trimming behavior for this assembly.

Bindings/Fun.Blazor.Microsoft.Authorization · high confidence

Added Fun.Blazor DSL bindings for ASP.NET Core Authorization components

This change introduces new F\# DSL bindings for the Microsoft.AspNetCore.Components.Authorization namespace, enabling declarative authorization UI patterns within Fun.Blazor applications. The diff adds builders and DSL operators for AuthorizeView (including Policy and Roles support), AuthorizeViewCore, and CascadingAuthenticationState. Users can now leverage these bindings to conditionally render content based on user authentication status and authorization policies using the Fun.Blazor syntax.

Bindings/Fun.Blazor.Microsoft.Authorization/Fun.Blazor.Bindings · high confidence

Fun.Htmx 4.1.4 release with SSE support and browser compatibility fixes

This release introduces Server-Sent Events (SSE) support for Blazor components via the new HxSseComponent and associated DSL helpers (hxSseConnect, hxSseSwap, etc.), allowing real-time streaming updates. It also adds a new hxGetEmpty helper to clear element content via static DOM requests and exposes the full hxEvt module with all htmx event literals for better type safety. Additionally, it fixes a NativeJs UpdateQueries browser compatibility issue and includes build optimizations such as ILLink substitutions to reduce asset size.

Fun.Htmx · high confidence

HtmlTemplate v4.1.0 introduces SSRTemplate and performance optimizations

The Fun.Blazor.HtmlTemplate library has been updated to version 4.1.0, introducing a new SSRTemplate module designed to generate HTML strings suitable for server-side rendering and integration with htmx, distinct from the standard Blazor runtime rendering. This release also includes significant performance improvements to the template HTML generation logic, such as caching and optimized node building, alongside a new ILLink.Substitutions.xml configuration to reduce the final asset size by removing F\# signature and optimization compressed data resources.

Fun.Blazor.HtmlTemplate · high confidence

Initial F\# bindings for Radzen Blazor components

Added a new F\# DSL binding layer for the Radzen Blazor UI library, exposing core components such as RadzenComponent, RadzenRow, RadzenStack, RadzenAlert, and RadzenBody. This enables developers to construct Radzen-based user interfaces using idiomatic F\# syntax, including support for layout controls, alert styling, and event handling, along with IL Linker configuration to optimize the resulting assembly size.

Bindings/Fun.Blazor.Radzen · high confidence

Initial Fluent UI Blazor bindings and solution structure

This change introduces the \Fun.Blazor.Microsoft.FluentUI\ project, providing F\# DSL bindings for the Microsoft Fluent UI Blazor component library. The diff adds the solution file (\Bindings.sln\) which registers the new Fluent UI project alongside other existing bindings (AntDesign, ApexCharts, MudBlazor, etc.) and tools (Cli, Generator). It also adds the core binding implementation file (\Microsoft.FluentUI.AspNetCore.Components.fs\), which defines builder types for Fluent UI components such as \FluentNavMenu\, \FluentAccordion\, and their items, exposing attributes like \Id\, \Disabled\, \Href\, \Icon\, \Expanded\, and event callbacks (\OnAction\, \ExpandedChanged\) via custom operations. Additionally, an \ILLink.Substitutions.xml\ file is added to configure linker substitutions for the assembly, specifically removing F\# signature and optimization compressed data resources to reduce bundle size.

Bindings/Fun.Blazor.Microsoft.FluentUI · high confidence

Initial release of the Fun.Blazor documentation website

The Fun.Blazor documentation site is now available as a WebAssembly application, providing a comprehensive showcase of the library's capabilities. The site features a responsive layout built with MudBlazor, including a dark/light theme switcher, a collapsible navigation drawer, and a multi-language support system (English and Chinese). It includes a dedicated demo section with interactive examples and source code viewing, as well as a documentation viewer that supports server-side rendering and prerendering for improved performance. The application also implements custom routing, error boundaries, and code syntax highlighting via Prism.js.

Fun.Blazor.Docs.Wasm · high confidence

Initial repository setup with F\# coding standards and build infrastructure

The repository is initialized with a new solution structure (Fun.Blazor.sln) and a comprehensive build pipeline (build.fsx) that handles environment checks, testing, documentation generation, and NuGet packaging for core projects and bindings. To ensure consistent code formatting, a new .editorconfig file is added with specific F\# style rules, replacing the previous .gitattributes configuration. The project also includes a new LICENSE (MIT), a README with usage instructions and benchmarks, and utility scripts (crawler.fsx, docs.fsx) for generating DSL bindings and documentation.

(repo-wide) · high confidence

Introduce Fun.Blazor.CustomElements for lazy-loading Blazor components as web components

This release adds the Fun.Blazor.CustomElements library, enabling Blazor components to be registered and rendered as custom HTML elements with lazy-loading capabilities. Users can now use the \html.customElement\ DSL to define custom elements that support pre-rendering and deferred initialization via conditions such as click events, viewport visibility, or time delays, using the \RenderAfter\ types. The library provides DI extensions (\RegisterCustomElementForFunBlazor\) to register components by type or entire assemblies, and includes JavaScript helpers (\CustomElement.lazyBlazorJs\) to manage the Blazor runtime initialization and DOM replacement. A new \FunBlazorCustomElementAttribute\ allows explicit control over the custom element tag names, and the package is configured with ILLink substitutions to reduce the final asset size.

Fun.Blazor.CustomElements · high confidence

Introduce Fun.Blazor.HotReload package for live code reloading

The new Fun.Blazor.HotReload package enables live reloading of Blazor components during development. It provides an \html.hotReloadComp\ DSL helper to wrap components, connecting to a SignalR hub (defaulting to localhost:9025) to receive code and CSS changes. The implementation uses MessagePack for efficient serialization and F\# compiler infrastructure to dynamically evaluate and inject updated render functions, supporting both parameterless and single-argument render entries.

Fun.Blazor.HotReload · high confidence

Introduce adaptive rendering and form management components

Fun.Blazor adds a new adaptive rendering model and form handling system. The \AdaptiveComponent\ and \AdaptiviewBuilder\ enable declarative, reactive UI updates driven by \AVal\ (adaptive values), allowing developers to build components that re-render only when underlying data changes, with options for static mode and event-trigger suppression. The \AdaptiveForm\ provides a structured way to manage form state, validation, and loading states for records and complex types, supporting lazy validation and sub-forms. Additionally, \DIComponent\ and \IComponentHook\ expose lifecycle events and dependency injection services within the component tree, facilitating better testability and resource management for hooks.

Fun.Blazor · high confidence

New ApexCharts bindings for Fun.Blazor

This change introduces the Fun.Blazor bindings for the ApexCharts library, adding the ApexChartBuilder, ApexGaugeBuilder, and ApexBaseSeriesBuilder components in ApexCharts.fs. These bindings expose a comprehensive set of chart configuration options (such as Title, Width, Height, and Options) and event handlers for user interactions including clicks, hovers, zooming, scrolling, and annotation events. The entry also includes an ILLink.Substitutions.xml file to optimize the published bundle size by removing F\# signature and optimization compressed data resources.

Bindings/Fun.Blazor.ApexCharts · high confidence

New DSL bindings for ASP.NET Core Blazor components

Added F\# DSL bindings for several ASP.NET Core Blazor components, including ErrorBoundary, FocusOnNavigate, NavLink, HeadContent, HeadOutlet, PageTitle, Virtualize, and EditForm. These bindings expose component-specific attributes and content slots (such as ErrorContent, Selector, ActiveClass, ItemSize, and Enhance) to allow users to compose these Blazor elements directly within the Fun.Blazor DSL.

Bindings/Fun.Blazor.Microsoft.Web/Fun.Blazor.Bindings · high confidence

New F\# DSL bindings for MudBlazor components

This release introduces a new set of F\# DSL bindings for the MudBlazor UI library, located in Fun.Blazor.Bindings. The new file, MudBlazor.fs, provides builder types and custom operations for a wide range of MudBlazor components, including buttons (MudButton, MudIconButton, MudFab), app bars, drawers, popovers, and tables. This allows users to construct MudBlazor UI elements using a fluent, type-safe F\# syntax within Fun.Blazor applications.

Bindings/Fun.Blazor.MudBlazor/Fun.Blazor.Bindings · high confidence

Behavioural changes

Fun.Blazor.Cli v4.1.2 defaults generator to 4.1.1 and deprecates watch command

The CLI now defaults the --generator-version argument to 4.1.1 (up from 4.1.0), ensuring generated code aligns with the latest generator improvements. Additionally, the 'watch' command used for hot-reload is marked as obsolete, signaling that this feature is being phased out in favor of other update mechanisms.

Fun.Blazor.Cli · high confidence

Fun.Blazor.Reactive 4.1.0: Reactive component rendering and trimming improvements

This release updates the Fun.Blazor.Reactive library to version 4.1.0. The \html.watch\ and \html.watch2\ DSL methods now use \html.region\ instead of \html.mergeNodes\ for rendering store updates, which changes how dynamic node updates are handled in the Blazor render tree. The \ReactiveComponent\ type now includes a \DynamicDependency\ attribute to ensure compatibility with .NET Native AOT trimming, and an \ILLink.Substitutions.xml\ file has been added to remove F\# signature and optimization compressed data resources, further reducing the final asset size. Additionally, minor documentation and formatting fixes were applied to the \Extensions.fs\ and \ReactiveComponent.fs\ files.

Fun.Blazor.Reactive · high confidence

Fun.Blazor.Server 4.1.0 release with SSR caching, antiforgery, and Parsable support

This release introduces several enhancements to the server-side Blazor integration. Developers can now control HTTP caching for server-side rendered components via the new ComponentResponseCacheAttribute, which applies Vary, Pragma, and Cache-Control headers. Antiforgery protection is enabled by default for MapRazorComponentsForSSR and MapCustomElementsForRazor, with an option to disable it. The new Parsable\<'T\> type simplifies passing complex data types in query strings or HTML attributes by automatically handling JSON serialization and base64 encoding. Additionally, the library now supports .NET 6 for MapRazorComponentsForSSR and includes performance improvements for custom element builds.

Fun.Blazor.Server · high confidence

Generator now supports CE style code generation and deprecates Feliz style

The Fun.Blazor.Generator now exclusively supports the CE (Computation Expression) style for generated code, removing support for the legacy Feliz style. This change introduces a new CEGenerator module that produces code with improved performance and lower allocation by distinguishing attributes and children directly, avoiding the overhead of converting FunBlazorNode to Bololo Node. Users must update their generator configuration to use the CE style, as the Feliz style is now deprecated and will throw an error.

Fun.Blazor.Generator · high confidence

Optimized Elmish DSL with inline lambdas for better performance

The Elmish integration API in Fun.Blazor.Elmish has been updated to use inline lambdas (via the \[\<InlineIfLambda\>\] attribute) for the init, update, and view functions in both the static \html.elmish\ members and the \hook.UseElmish\ extension. This change reduces the overhead of delegate creation and improves build performance for Blazor applications using this library. Additionally, the package version has been bumped to 4.1.0, and an ILLink substitution file was added to remove F\# signature and optimization compressed data resources, further reducing the final asset size.

Fun.Blazor.Elmish · high confidence

Updated Ant Design component bindings and added IL Linker configuration

The Fun.Blazor.AntDesign bindings have been updated to reflect changes in the underlying Ant Design library, including new or modified attributes for components such as Dropdown, Popconfirm, Popover, and Tooltip (e.g., Arrow, ArrowPointAtCenter, MouseEnterDelay). Additionally, an ILLink.Substitutions.xml file has been added to the project to configure the .NET linker to remove specific F\# signature and optimization compressed resources, ensuring smaller and more efficient published assemblies.

Bindings/Fun.Blazor.AntDesign · high confidence

Updated demo code to use new DSL syntax and features

The demo files in Fun.Blazor.Docs.Wasm/Demos have been refactored to use the updated Fun.Blazor DSL. This includes replacing the old \adaptiview\ computation expression with the new \adapt\ syntax, switching from \html.comp\ to \html.inject\ for component hooks, and updating MudBlazor component calls to use the new \''\ suffix (e.g., \MudButton''\). Additionally, new demos were added to showcase \AdaptiviewMixDemo\ (mixing observables and stores), \AsyncInjectionDemo\ (async injection), \CounterClassStyle\ (class-based components), and \CustomElementDemo\ (custom elements with pre-render and delay options). The \AdaptiveForm\ demo was also enhanced to support nested sub-forms and lazy validation.

Fun.Blazor.Docs.Wasm/Demos · high confidence

Test coverage

Added comprehensive test suite for Fun.Blazor

Added a new set of unit and integration tests covering core library functionality, including the AdaptiveForm state management, adaptive HTML rendering, component hooks, routing, dependency injection scoping, internationalization, query building, and server-side rendering. The tests also verify htmx integration, DOM event handling, style generation, and template rendering.

Fun.Blazor.Tests · high confidence

Dependencies

Fun.Blazor.Wasm 4.1.0 release with dependency upgrades and size optimizations

This release updates the Fun.Blazor.Wasm package to version 4.1.0, incorporating dependency upgrades and build pipeline improvements. The package now includes an ILLink.Substitutions.xml configuration to remove F\# signature and optimization compressed data resources, reducing the final WebAssembly asset size. Additionally, the release introduces DI extension methods in DIExtensions.fs for registering core services like ShareStore, ScopedCssRules, and GlobalStore, and simplifies root component registration via a new AddFunBlazor method.

Fun.Blazor.Wasm · high confidence

Initial release of Fun.Blazor 4.1.0 with .NET 10 support and new bindings

This release introduces the initial project structure for Fun.Blazor 4.1.0, establishing comprehensive support for .NET 10 across the core library, CLI, documentation, and test suites. It adds new F\# bindings for major UI libraries including AntDesign, ApexCharts, BlazorMonaco, MudBlazor, Radzen, and Z.Blazor.Diagrams, alongside official Microsoft bindings for ASP.NET Core Authorization, FluentUI, QuickGrid, and Web components. The release also includes new packages for Elmish integration, HTML templating, reactive state management, and hot-reload capabilities, while upgrading the CLI to target .NET 8 and ensuring all packages are configured for trimmability.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 38 → 39 (+0.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 71 → 56 (-14.8)
  • Architecture 92 → 99 (+6.3)
  • Maturity 56 → 57 (+0.1)
  • Readiness 52 → 52 (-0.1)
  • Security 28 → 30 (+1.7)
  • Accessibility 34 → 36 (+2.0)
  • Performance 60 → 60 (+0.0)

Resolved (20)

  • Coverage not measured — no coverage collector is wired up
  • Documentation: no project overview (Docs/40 Advanced/README.md)
  • IL efficiency: 34 authored method(s) exceed the IL budget (Fun.Blazor.HotReload/Interpreter.fs)
  • Inconsistent return types for DSL entry points: 'stylesheet' returns the final 'NodeRenderFragment' immediately, while 'ruleset' and 'keyframes' return intermediate builder objects ('RulesetBuilder', 'KeyFramesBuilder') that require a subsequent 'Run' call. This forces users to use different patterns for different CSS constructs.
  • Naming inconsistency for builder execution: One builder uses 'Run' to produce a render fragment, the other uses 'Run' to produce a string. While the return types differ, the parallel naming suggests a unified pattern. However, 'StyleStrBuilder' is an internal implementation detail that breaks the abstraction if users expect 'Run' to always return a UI node. More critically, 'RulesetBuilder' also uses 'Run' but returns a different type. This is a minor internal inconsistency.
  • No ADRs found
  • Outdated: Microsoft.AspNetCore.Components.CustomElements
  • Outdated: Microsoft.Extensions.ObjectPool
  • Outdated: Microsoft.FluentUI.AspNetCore.Components
  • Outdated: MudBlazor
  • Projects may be oversized for their cohesion
  • TooManyMethods: FluentAutocompleteBuilder`2 (Bindings/Fun.Blazor.Microsoft.FluentUI/Fun.Blazor.Bindings/Microsoft.FluentUI.AspNetCore.Components.fs)
  • TooManyMethods: FluentDesignSystemProviderBuilder`1 (Bindings/Fun.Blazor.Microsoft.FluentUI/Fun.Blazor.Bindings/Microsoft.FluentUI.AspNetCore.Components.fs)
  • TooManyMethods: FluentPopoverBuilder`1 (Bindings/Fun.Blazor.Microsoft.FluentUI/Fun.Blazor.Bindings/Microsoft.FluentUI.AspNetCore.Components.fs)
  • TooManyMethods: FluentProfileMenuBuilder`1 (Bindings/Fun.Blazor.Microsoft.FluentUI/Fun.Blazor.Bindings/Microsoft.FluentUI.AspNetCore.Components.fs)
  • Workflow token permissions not restricted (.github/workflows/Build and publish nuget package for bindings.yml)
  • Workflow token permissions not restricted (.github/workflows/Build and publish nuget package.yml)
  • Workflow token permissions not restricted (.github/workflows/Deploy to GitHub Pages.yml)
  • Workflow token permissions not restricted (.github/workflows/PR check.yml)
  • XML-doc coverage: CSharpComponents (Benchmark/CSharpComponents/CSharpComponents.csproj)

New (16)

  • High CVE: Microsoft.AspNetCore.WebUtilities 8.0.11 (Bindings/Fun.Blazor.AntDesign/Fun.Blazor.AntDesign.fsproj)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • No ADRs found (Fun.Blazor.Cli/Fun.Blazor.Cli.fsproj)
  • Outdated: Blazor-ApexCharts
  • Outdated: Microsoft.AspNetCore.Components.CustomElements (Fun.Blazor.CustomElements/Fun.Blazor.CustomElements.fsproj)
  • Outdated: Microsoft.AspNetCore.Components.WebAssembly
  • Outdated: Microsoft.AspNetCore.Components.WebAssembly.DevServer
  • Outdated: Microsoft.AspNetCore.Components.WebAssembly.Server
  • Outdated: Microsoft.Extensions.ObjectPool (Fun.Blazor/Fun.Blazor.fsproj)
  • PR-triggered workflow without a permissions block (.github/workflows/PR check.yml)
  • TooManyMethods: FluentButtonBuilder`1 (Bindings/Fun.Blazor.Microsoft.FluentUI/Fun.Blazor.Bindings/Microsoft.FluentUI.AspNetCore.Components.fs)
  • TooManyMethods: FluentFieldBuilder`1 (Bindings/Fun.Blazor.Microsoft.FluentUI/Fun.Blazor.Bindings/Microsoft.FluentUI.AspNetCore.Components.fs)
  • TooManyMethods: RadzenChartBuilder`1 (Bindings/Fun.Blazor.Radzen/Fun.Blazor.Bindings/Radzen.Blazor.fs)
  • TooManyMethods: RadzenInlineAIPromptBuilder`1 (Bindings/Fun.Blazor.Radzen/Fun.Blazor.Bindings/Radzen.Blazor.fs)
  • Workflow holding a long-lived secret is unscoped (.github/workflows/Deploy to GitHub Pages.yml)

Changes since last survey

  • 2 commits — 2 feature/other, 0 fixes

By area

  • .github/workflows — 1 commit
  • Bindings/Fun.Blazor.Microsoft.FluentUI — 1 commit

Notable commits

  • change: Update bindings
  • change: Use nuget trusted publisher

Architecture

  • Unchanged — 0 containers · 6 contexts · 1 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

slaveOftime/Fun.Blazor was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit be51c620176d1ec8f569479e891c1cc82925fb15 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.