Lanayx/Oxpecker

Oxpecker is an F\# web framework built on ASP.NET Core that provides a functional DSL for routing, model binding, and middleware composition. It extends this backend capability with a dedicated ViewEngine for generating HTML and typed bindings for client-side libraries like Solid.js, HTMX, and Alpine.js. The system supports modern web patterns through features such as streaming responses, automatic OpenAPI generation, and comprehensive testing infrastructure.

49 changes.

This period focused on the initial release and stabilization of the Oxpecker F\# web framework, introducing core features like model binding, streaming, and OpenAPI generation. It simultaneously established the Oxpecker.Solid ecosystem by releasing bindings for Solid.js and a Fable compiler plugin, enabling F\#-based frontend development. The work was validated through extensive test coverage and a suite of example applications demonstrating these new capabilities.

8 changes.

This period focused on expanding the framework's frontend capabilities with the introduction of the Oxpecker.Alpine package for typed Alpine.js directives. Concurrently, significant effort was dedicated to increasing test coverage across SolidJS meta bindings, pattern matching, SVG rendering, and Htmx4 attributes, while also validating OpenAPI schema generation.

A new example application demonstrating CRUD operations has been added to the repository. It includes a solution file defining Backend, Frontend, and Shared projects, along with a README explaining how to run the JSON API backend using .NET and the Oxpecker.Solid frontend using npm.

examples/CRUD · high confidence

The ContactApp example now provides a complete HTMX-based contact management interface, including listing, searching, adding, editing, viewing, and deleting contacts, along with bulk deletion and an asynchronous ZIP archive feature. The app demonstrates Oxpecker's model validation capabilities, specifically dynamic email validation and required field checks, while using in-place updates and flash messages for user feedback.

examples/ContactApp · high confidence

A new TodoList example has been added to the examples directory, demonstrating a F\# (Fable) application built with Solid.js, Solid Router, and Tailwind CSS. The example includes a Vite configuration that integrates the Solid and Tailwind plugins, an HTML entry point, and an SVG icon. It serves as a reference implementation for setting up a F\# frontend with these specific technologies.

examples/TodoList · high confidence

A new Empty sample application has been added to the examples directory, demonstrating a minimal ASP.NET Core setup using the Oxpecker library with a single 'Hello World!' endpoint.

examples/Empty · high confidence

A new example project named EmptySolid has been added to the repository, providing a minimal starting point for Oxpecker.Solid applications. This template includes the necessary configuration for Vite with the Solid plugin, a basic F\# application structure using Oxpecker.Solid components, and instructions for running the development server and building the app.

examples/EmptySolid · high confidence

Added a new example in the examples/MCP directory that demonstrates how to implement a Model Context Protocol (MCP) server and client using F\#. The server (Server/Program.fs) exposes a tool to get the current date via an HTTP transport, while the client (Client/Program.fs) connects to this server, retrieves available tools, and uses them with a local Ollama model to answer user prompts. A README.md provides instructions for running the example.

examples/MCP · high confidence

A new example application has been added to the repository, demonstrating an Oxpecker, Htmx, and Alpine.js implementation of the standard Blazor Weather sample. The app includes models for weather forecasts, routing for home, counter, and weather pages, and integrates antiforgery middleware for security. A README is also provided to explain the setup and link to a comparative article.

examples/WeatherApp · high confidence

The TodoList example now includes a complete task management interface allowing users to add, delete, and reorder tasks. The implementation features a new TodoItem component and uses Tailwind CSS for styling. Accessibility is improved with ARIA labels on buttons and the list container. Two implementation patterns are provided: a standard signal-based approach and an alternative using Solid stores, both supporting the same core functionality.

examples/TodoList/src/Components · high confidence

Introduced a new shared library module defining the core data structures for the CRUD example application. This includes types for Product, Order, OrderItem, and NewOrder, along with a strongly-typed Id type based on Guid, providing the foundational domain models used across the application.

Shared · high confidence

The Frontend now includes a shared module that defines the API client logic for the CRUD example. It establishes connections to the backend at localhost:5000 and implements functions to fetch orders, order details, and products, as well as to create and delete orders. This module also initializes reactive resources for orders and products to support the UI state.

Frontend · high confidence

Added a new TodoList example application in the examples/TodoList/src directory. This entry point introduces client-side navigation using Oxpecker.Solid.Router, featuring an 'About' page accessible via links, and applies Tailwind CSS for styling. The implementation includes a root layout with metadata support and demonstrates the use of Solid components for rendering the todo list and navigation.

examples/TodoList/src · high confidence

Added a new shared layout template for the WeatherApp example that integrates HTMX (version 4.0.0) and Alpine.js (version 3.15.11) via CDN. The layout provides a responsive navigation menu with active link highlighting based on the current request path, and configures the body element with HTMX boosting enabled to enhance standard links and forms with asynchronous updates.

examples/WeatherApp/templates/shared · high confidence

The WeatherApp example now includes template files for the Counter, Home, Error, and Weather pages, demonstrating the framework's new support for HTMX and Alpine.js. The Counter page uses Alpine.js for local state management, while the Weather page utilizes HTMX to fetch and swap data via AJAX requests. The templates also incorporate Bootstrap 5.1.0 for styling and include CSRF protection tokens in forms.

examples/WeatherApp/templates · high confidence

Oxpecker is introduced as a new F\# framework built on top of ASP.NET Core Endpoint Routing, offering a functional DSL for building web applications. This release provides core infrastructure including \EndpointHandler\ and \EndpointMiddleware\ composition, routing with \routef\ template support, and model binding for JSON, forms, and query strings. It also includes built-in response handlers for writing text, JSON, and HTML views, along with model validation, dependency injection integration, and middleware for response caching.

src/Oxpecker · high confidence

The Oxpecker.Solid.FablePlugin is now available as a standalone NuGet package. This Fable compiler plugin transforms Oxpecker View Engine computation expressions into Solid-compatible JSX, enabling users to build Solid.js applications using the Oxpecker syntax. The plugin includes documentation and supports debugging via the SolidComponentFlag.Debug attribute.

src/Oxpecker.Solid.FablePlugin · high confidence

This change introduces the new Oxpecker.Solid library, providing Fable bindings for Solid.js, Solid Router, and Solid Meta. It enables developers to build Solid.js applications in F\# using a computation-expression-based syntax, supporting features such as signals, the For and Index loops, event handlers, and the Fragment element. The package also includes specific bindings for client-side routing via Solid Router and document head management via Solid Meta, along with comprehensive support for ARIA attributes and SVG elements.

src/Oxpecker.Solid · high confidence

This change introduces the Oxpecker.ViewEngine library, providing a domain-specific language (DSL) for building HTML views in F\#. It includes core node types for tags, containers, void elements, and text (including raw and integer variants), along with support for attributes and child elements. The engine features a StringBuilder-based rendering pipeline with HTML escaping, supports prerendering static templates to improve performance, and allows for layout patterns via 'holes' in templates.

Oxpecker.ViewEngine · high confidence

The Basic example now includes a comprehensive Program.fs demonstrating Oxpecker's core features, including various route patterns (static, parameterized, catch-all), middleware application (headers, caching, authorization), and response handling (JSON, text, chunked JSON, and multipart HTML streaming). It also highlights integration with HTMX 4 for client-side interactions and OpenAPI documentation generation.

examples/Basic · high confidence

Added a new F\# backend example in the examples/CRUD/Backend directory that implements a JSON API for basic Create, Read, Update, and Delete operations on orders and products. The example uses the Oxpecker library for routing and dependency injection, featuring in-memory database storage initialized with sample data. It includes abstractions for database clients and logging, handlers for HTTP endpoints, and services that enforce business logic such as stock validation during order creation and updates.

examples/CRUD/Backend · high confidence

The new \Oxpecker.Alpine\ package extends \Oxpecker.ViewEngine\ with typed, fluent extension methods for Alpine.js directives. Users can now compose Alpine components directly in F\# using methods like \xData\, \xOn\, \xModel\, \xShow\, and \xTransition\. The package includes helper modules (\XOnModifier\, \XModelModifier\, \XTransitionModifier\, etc.) to easily apply common modifiers and stages, providing IDE support for JavaScript expressions within the F\# code.

src/Oxpecker.Alpine · high confidence

Introduces the \Oxpecker.OpenApi\ package, which extends the Oxpecker framework to automatically generate OpenAPI specifications from F\# code. The library provides \addOpenApi\ and \addOpenApiSimple\ functions to attach metadata to endpoints, supporting both ASP.NET Core's native OpenAPI (9+) and Swashbuckle (8+). It includes transformers to handle F\#-specific types, such as \Option\<\\>\, \ValueOption\<\\>\, and discriminated unions (including recursive unions and \UseNullAsTrueValue\ patterns), ensuring accurate schema generation for request bodies, response bodies, and path parameters.

src/Oxpecker.OpenApi · high confidence

Added a new frontend example for the CRUD application, built with the Oxpecker.Solid framework and Tailwind CSS. The app provides a user interface to create, view, and delete orders by communicating with a backend server at http://localhost:5000 using the Thoth.Fetch library. It includes components for listing orders, expanding order details, and creating new orders with item selection.

examples/CRUD/Frontend · high confidence

This change introduces the core backend infrastructure for the CRUD example, adding the \Database.fs\ module which implements repository logic for Orders and Products (including read, create, update, and delete operations) and a \Fake\ module for in-memory data simulation. It also adds \Env.fs\, which defines the \Env\ record to wire together logging and database client interfaces, enabling the backend to execute SQL statements and manage application state.

Backend · high confidence

Oxpecker introduces a new model binder that uses TypeShape for parsing, including a configurable MaxCollectionSize to prevent unbounded allocation denial-of-service attacks. It adds support for multipart responses (compatible with htmx hx-multipart) via IMultipartPart and built-in parts like HtmlPart and JsonPart. The library also adds HTTP preconditional handling (ETag, Last-Modified, If-Match, etc.) and streaming support with HTTP Range header processing.

Oxpecker · high confidence

The Oxpecker.Htmx package has been updated to target HTMX 4.0, introducing a clean break from the previous 2.x API. This update adds fluent extension methods for core HTMX 4 attributes (such as hxGet, hxPost, hxSwap, and hxOn), new request and response header constants (including the new HX-Source header), and comprehensive support for built-in HTMX 4 extensions like hx-sse, hx-ws, hx-multipart, and hx-live. It also provides helper modules for modifiers, extended selectors, and swap methods to facilitate the new HTMX 4 features.

src/Oxpecker.Htmx · high confidence

The new Oxpecker.ViewEngine library introduces a code-as-markup HTML rendering engine built on F\# computation expressions. This release adds comprehensive ARIA support via the new Aria module, enabling accessibility attributes like role, aria-label, and aria-hidden directly on HTML elements. It also introduces HTML streaming capabilities through the Render module, allowing views to be written to streams, buffer writers, and text writers with cancellation support. Performance is improved via a custom HTML encoder, UTF-8 chunked writing, and a StringBuilder pool, while the Tags module provides a wide range of standard HTML tags and global attributes.

src/Oxpecker.ViewEngine · high confidence

The repository has been initialized with a comprehensive set of configuration files and documentation. This includes \.editorconfig\ and \.fantomasignore\ to enforce F\# coding standards and formatting exclusions, \global.json\ to pin the .NET SDK version (11.0.100-rc.1), and \.slnx\ solution files to structure the backend (\Oxpecker\) and frontend (\Oxpecker.Solid\) projects. Documentation has been significantly expanded with a new \README.md\, \AGENTS.md\ defining repository guardian protocols, and \MigrateFromGiraffe.md\ detailing the API differences and migration path from the Giraffe framework. Jekyll configuration (\\_config.yml\) and \.gitignore\ updates are also included to support documentation hosting and build artifact management.

(repo-wide) · high confidence

The ContactApp now includes a new site.css file and a spinning-circles.svg asset to enhance user interface feedback. The CSS defines styles for error messages, alert banners, progress bars, and loading spinners, while also introducing CSS animations for fading out elements and swapping table rows, providing smoother visual transitions during interactions.

examples/ContactApp/wwwroot · high confidence

The ContactApp example templates have been restructured to support HTMX 4 (via the CDN link in layout.fs) and integrate the Oxpecker.ModelValidation library. A new shared layout introduces flash message display, while new shared modules (contactFields.fs, errors.fs) provide reusable components for rendering contact form fields with dynamic, client-side email validation triggered via HTMX requests, and consistent error message display.

examples/ContactApp/templates/shared · high confidence

The ContactApp example templates (edit, index, new, show) have been rewritten to use the Oxpecker ViewEngine DSL instead of raw HTML strings. This change introduces client-side interactivity via Htmx attributes: the index page supports dynamic search with debounced keyup triggers, infinite scroll for paginated results, and bulk deletion of selected contacts. The edit page includes an Htmx-powered delete button with confirmation, and the index page features a dynamic archive UI that updates its status (waiting, running, complete) via Htmx polling. Validation support is also integrated via Oxpecker.ModelValidation in the new and edit forms.

examples/ContactApp/templates · high confidence

The Oxpecker.Solid HTML builder now supports rendering integer values as text content, allowing users to embed numbers directly in their markup without explicit conversion. Additionally, the underlying node types (RegularNode, FragmentNode, VoidNode) have been refactored into interfaces to improve flexibility, and the builder infrastructure has been updated to support per-tag attributes, enabling more granular control over HTML element properties.

Oxpecker.Solid · high confidence

Added HelloWorld test case for Oxpecker.Solid; Added JSON serialization and model binding performance benchmarks; Added performance benchmarks for model binding, routing, and view engines; Added test coverage for SVG component rendering; Added test coverage for Solid component children passing; Added test coverage for Solid component signal usage; Added test coverage for Solid refs; Added test coverage for Solid.js Signal component creation and updates; Added test coverage for component parameter handling and conditional rendering; Added test coverage for deep nested HTML tag structures; Added test coverage for flat nested tag structures; Added test coverage for pattern matching branches; Added test suite for Solid.js compiler features and error handling; Added tests for @solidjs/meta bindings; Added tests for Alpine.js directive attributes; Added tests for Htmx4 attribute support and extensions; Added tests for OpenAPI schema generation and F\# type transformers; Added tests for Solid Router integration; Added tests for Solid conditional rendering components; Added tests for Solid event handler syntax; Added tests for cancellation, model parsing, and validation; Added tests for core Oxpecker features; Added tests for custom Solid components and imported tags; Added tests for custom attribute handling; Added tests for view rendering, HTML encoding, and utility functions.

The Oxpecker F\# web framework and its ecosystem have been updated to target .NET 10 (with some components like OpenApi and example apps targeting .NET 11) and Fable 5. This includes major version bumps for core packages such as Oxpecker (3.0.0-beta-2), Oxpecker.ViewEngine (3.0.0-beta-1), Oxpecker.Htmx (4.0.0), and Oxpecker.Solid (1.0.0). The update introduces new example applications including Basic, CRUD, ContactApp, Empty, EmptySolid, MCP, TodoList, and WeatherApp, demonstrating various features like Solid.js integration, HTMX 4 support, and Alpine.js. Additionally, the project now includes a Gemfile for Jekyll-based documentation and updates to test suites using xUnit v3 and FsUnit.Light.

(dependencies) · high confidence

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

• CAI 56 → 56 (-0.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 92 → 92 (+0.3)
• Architecture 54 → 53 (-0.6)
• Maturity 53 → 57 (+3.7)
• Readiness 53 → 49 (-3.7)
• Security 69 → 81 (+12.4)

• Dependency hygiene not measured — no packages were read
• Duplicated block (10 lines × 3) (src/Oxpecker.Solid/SolidBindings.fs)
• Duplicated block (12 lines × 2) (examples/Basic/Program.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/SolidBindings.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (12 lines × 2) (src/Oxpecker.ViewEngine/Render.fs)
• Duplicated block (12 lines × 3) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (12 lines × 6) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (13 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (13 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (14 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (14 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (14 lines × 4) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (15 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (16 lines × 2) (src/Oxpecker.ViewEngine/IdeTweaks.fs)
• …and 27 more

• Documentation: no installation or build instructions (README.md)
• Duplicated block (11 lines × 2) (src/Oxpecker.Solid/SolidBindings.fs)
• Duplicated block (11 lines × 2) (src/Oxpecker.ViewEngine/Tags.fs)
• Duplicated block (11 lines × 3) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (11 lines × 3) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (12 lines × 3) (src/Oxpecker.Solid/SolidBindings.fs)
• Duplicated block (12–13 lines × 2) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (12–13 lines × 9) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (13 lines × 2) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (13 lines × 5) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (14–15 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (15 lines × 2) (examples/CRUD/Frontend/src/Program.fs)
• Duplicated block (16–17 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (16–17 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (16–17 lines × 4) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (17 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (18 lines × 2) (src/Oxpecker.Solid/Svg.fs)
• Duplicated block (19 lines × 2) (src/Oxpecker.Alpine/IdeTweaks.fs)
• Duplicated block (19–20 lines × 3) (src/Oxpecker.Solid/Tags.fs)
• Duplicated block (20 lines × 2) (src/Oxpecker.Solid/Tags.fs)
• …and 24 more

• 19 commits — 17 feature/other, 2 fixes

• src/Oxpecker — 9 commits
• examples/ContactApp — 2 commits
• src/Oxpecker.Htmx — 2 commits
• tests/Oxpecker.Solid.Tests — 2 commits
• (root) — 1 commit
• .github/workflows — 1 commit
• src/Oxpecker.OpenApi — 1 commit
• src/Oxpecker.ViewEngine — 1 commit

• fix: Fix let-bound elements being silently dropped (with their next sibling) (#101)
• fix: Fixed contact app sample
• change: Add link to 'How to fully leverage Oxpecker' in README
• change: Added documentation for static files serving to the Oxpecker
• change: Bumped version
• change: Cancellation support across the API (#105)
• change: DU transformer implementation (#98)
• change: Improve performance of TryGet* extension methods
• change: Multipart JSON parts use the registered IJsonSerializer (#106)
• change: Multipart response support (#103)
• change: New QUERY Http method support (#104)
• change: Prerender functions (#102)
• change: Prevent binding exception on null query or form collections.
• change: Removed obsolete functionality
• change: Simplified release notes
• change: Support for Htmx4 general release
• change: Update .NET version
• change: Updated .net tools
• change: Updated packages versions to beta

• Containers 0 added · 0 removed · contexts 0 added · 4 removed · edges 1 added · 7 removed

• Basic
• ContactApp
• Oxpecker.OpenApi.Tests
• WeatherApp

• Oxpecker.Tests → Oxpecker.ViewEngine

• Basic → Oxpecker
• Basic → Oxpecker.ViewEngine
• ContactApp → Oxpecker
• ContactApp → Oxpecker.ViewEngine
• Oxpecker.OpenApi.Tests → Oxpecker
• WeatherApp → Oxpecker
• WeatherApp → Oxpecker.ViewEngine

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

Lanayx/Oxpecker 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.