slaveOftime/Fun.Blazor

Fun.Blazor is an F\# library that provides a domain-specific language for building Blazor applications, enabling developers to write UI components using idiomatic F\# syntax. It offers comprehensive bindings for major UI frameworks like MudBlazor, Ant Design, and Fluent UI, alongside core features for reactive state management, adaptive rendering, and server-side rendering. The system also supports advanced integration patterns such as Elmish architecture, htmx interactions, and lazy-loading web components, with a strong focus on performance optimization and trimmability.

10 changes.

This period established the Fun.Blazor project with its initial repository structure, build pipelines, and comprehensive documentation site. It introduced core features such as adaptive rendering, form management, and server-side HTML templating, while adding bindings for major UI libraries and supporting .NET 10. The work also included significant generator updates to adopt CE-style code generation and the implementation of a robust test suite.

9 changes.

This period focused on expanding the Fun.Blazor ecosystem with new packages for Elmish architecture, reactive state management, and custom web components. The work also included significant enhancements to server-side rendering, hot reloading, and htmx integration, alongside comprehensive documentation demos and performance benchmarking.

10 changes.

This period focused on significantly expanding the Fun.Blazor ecosystem by introducing new F\# DSL bindings for major UI libraries including Ant Design, ApexCharts, MudBlazor, Radzen, and Fluent UI. It also added comprehensive bindings for ASP.NET Core features such as QuickGrid, Authorization, and core Blazor components like ErrorBoundary and EditForm. A consistent effort was made to optimize assembly sizes by configuring the IL Linker to remove F\# signature and optimization compressed data across all new projects.

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

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

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

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

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

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

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

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

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

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

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

This change introduces the Fun.Blazor.Elmish package (version 4.1.0), providing Elmish architecture support for Blazor applications. It adds the \ElmComponent\ Blazor component and \html.elmish\ DSL helper to integrate Elmish programs into the Fun.Blazor rendering pipeline, along with \IComponentHook.UseElmish\ for managing state and commands within component lifecycles. The package includes an \ILLink.Substitutions.xml\ configuration to optimize trimming for .NET Native AOT scenarios and updates the underlying Elmish dependency.

Fun.Blazor.Elmish · high confidence

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

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

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

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

A new Fun.Blazor.Reactive package (version 4.1.0) has been added to provide reactive state management and UI updates in Blazor. It introduces an IStore\<'T\> abstraction with Publish, Observable, and Current members, along with a ReactiveComponent that subscribes to observables to trigger re-renders. The package exposes html.watch overloads to render nodes dynamically from single or multiple stores (watch, watch2, watch3), and adds extension methods on IComponentHook (UseStore, UseAVal, UseCVal) and IStoreManager (Create, CreateDeferred) to simplify store lifecycle and integration with adaptive values. It also includes html.bind for two-way binding to stores and an ILLink.Substitutions.xml to reduce trimmed asset size.

Fun.Blazor.Reactive · high confidence

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

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

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

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

The documentation site now includes a comprehensive set of new demo pages in the Fun.Blazor.Docs.Wasm/Demos folder. These additions illustrate key library capabilities: adaptive state management via Elmish integration (AdaptiveElmish, ElmishDemo), complex form validation with nested sub-forms and lazy validation (AdaptiveForm), and various adaptive view patterns including static views and reactive streams (AdaptiviewDemo, AdaptiviewMathDemo, AdaptiviewMixDemo). Additional demos cover custom web components (CustomElementDemo), scoped dependency injection (ScopedServiceDemo), global store synchronization across browser tabs (GlobalStoreDemo), HTML template rendering with custom events (HtmlTemplateDemo), and CSS styling features like inline styles and keyframe animations (InlineStyleDemo, CssRuleDemo, KeyFramesDemo).

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

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

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

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

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

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

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

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 36 → 37 (+1.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 76 → 76 (+0.0)
• Architecture 82 → 81 (-1.6)
• Maturity 58 → 60 (+1.8)
• Readiness 50 → 57 (+7.1)
• Security 26 → 29 (+2.5)
• Accessibility 27 → 27 (+0.0)

• Change coupling: AdaptiveComponent.fs ↔ DIComponent.fs (Fun.Blazor/AdaptiveComponent.fs)
• Code Duplication not included (time budget)
• Deprecated: xunit
• High CVE: MessagePack 2.4.59
• High CVE: MessagePack 2.4.59
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium CVE: MessagePack 2.4.59
• Medium CVE: MessagePack 2.4.59
• Medium CVE: MessagePack 2.4.59
• Medium CVE: MessagePack 2.4.59
• …and 13 more

• Coverage not measured — no coverage collector is wired up
• Documentation: no architecture or design documentation (Docs/40 Advanced/50 Adaptive/README.md)
• Documentation: no architecture or design documentation (Docs/40 Advanced/51 Elmish/README.md)
• High CVE: MessagePack 2.4.59
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No dependency advisory monitoring
• Outdated: Bolero
• Outdated: Microsoft.AspNetCore.TestHost
• Outdated: Microsoft.Testing.Extensions.CodeCoverage
• …and 4 more

• 7 commits — 7 feature/other, 0 fixes

• Fun.Blazor/CHANGELOG.md — 2 commits
• (repo) — 1 commit
• Bindings/Fun.Blazor.AntDesign — 1 commit
• Fun.Blazor.Tests/Components — 1 commit
• Fun.Blazor.Tests/Core — 1 commit
• Fun.Blazor.Tests/Fun.Blazor.Tests.fsproj — 1 commit

• change: Add Microsoft.NET.Test.Sdk
• change: Add StoreTests
• change: Bump Fun.Blazor to 4.1.11
• change: Improve tests
• change: Merge pull request #78 from slaveOftime/feature/maintain-2026-8
• change: Update Fun.Css to 1.1.0
• change: Update bindings

• Containers 0 added · 0 removed · contexts 6 added · 0 removed · edges 1 added · 0 removed

• Fun.Blazor
• Fun.Blazor.Cli
• Fun.Blazor.Docs.Wasm
• Fun.Blazor.Generator
• Fun.Blazor.HotReload
• Fun.Blazor.Server

• Fun.Blazor.Server → Fun.Blazor

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

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.