SaturnFramework/Saturn

This system is a functional web framework for F\# that provides a high-level, composable API for building HTTP and gRPC services on the .NET platform. It abstracts ASP.NET Core infrastructure to offer declarative routing, controller-based resource management, and WebSocket pub/sub capabilities. The framework also includes extensions for common authentication schemes, server hosting on Azure Functions, and performance benchmarking tools.

15 changes.

This period focused on modernizing the build infrastructure and upgrading to .NET 6, while significantly expanding the framework's capabilities with new authentication, routing, and hosting abstractions. The release introduced comprehensive support for controllers, real-time channels, and Azure Functions, accompanied by a broad set of sample applications demonstrating these features.

8 changes.

This period focused on expanding the framework's capabilities by adding native gRPC support and introducing new sample projects for .NET 6. The work included implementing gRPC integration within the Saturn framework and providing comprehensive examples for WebSocket, gRPC, Azure AD authentication, and background workers.

A new sample application (WorkerSample) has been added, demonstrating how to create a background worker service using the .NET 6 framework and the Giraffe library. The sample configures a hosted service that logs periodic messages and handles cancellation, providing a template for building long-running background tasks in .NET 6.

sample/WorkerSample · high confidence

A new sample project, AzureADAuthSample, has been added to demonstrate integrating Azure Active Directory authentication into a Saturn application. The sample includes the F\# implementation using the \Saturn.Extensions.Authorization\ package's \use\_azuread\_oauth\ extension, along with a README explaining how to configure tenant ID, client ID, and client secret to enable OAuth 2.0 authentication.

sample/AzureADAuthSample · high confidence

A new sample project has been added to demonstrate how to host a Saturn application on Azure Functions. The sample includes a F\# module that defines an HTTP-triggered function using the \Saturn.AzureFunctions\ abstraction, allowing users to see how to integrate Saturn controllers with the Azure Functions runtime.

sample/FunctionsSample · high confidence

A new sample application (CsrfSample) is added, showcasing how to implement CSRF protection using the Giraffe web framework. The sample includes a view engine integration for rendering HTML and demonstrates the use of \protectFromForgery\ middleware, token retrieval, and form submission handling within a Saturn application pipeline.

sample/CsrfSample · high confidence

A new sample application is added that demonstrates the use of the endpoint router in Saturn. The sample showcases controller versioning (e.g., userControllerV2 with version "2") and the ability to plug HttpHandler controllers as subcontrollers (e.g., commentController nested within userController). It also includes static file serving and header pipeline configurations.

sample/EndpointRoutingSample · medium confidence

Users can now configure the application to use the HTTP.sys web server on Windows, which provides features not available in Kestrel. This includes switching to HTTP.sys, applying custom HTTP.sys configuration, and enabling Windows authentication (NTLM/Negotiate) with optional anonymous access control.

src/Saturn.Extensions.HttpSys · high confidence

A new sample application demonstrating JWT-based authentication using Giraffe and Saturn is added. The sample includes a login endpoint that issues JWTs and a secured route that validates them, serving as a reference implementation for integrating JWT authentication in F\# web services.

sample/JWTSample · high confidence

A new sample application demonstrating Turbolinks integration with the Saturn and Giraffe frameworks. The sample includes a complete F\# MVC structure with layout, index, and other view components, utilizing the Giraffe.ViewEngine for rendering HTML. It also includes a paket.references file specifying the FSharp.Core dependency.

sample/TurbolinksSample · high confidence

A new Turbolinks extension has been added to Saturn, enabling seamless single-page application navigation. The update introduces a \TurbolinksMiddleware\ that automatically injects the \Turbolinks-Location\ header with the full request path and query string, and provides a \use\_turbolinks\ configuration method on the application builder to activate this behavior across all endpoints.

src/Saturn.Extensions.Turbolinks · high confidence

A new gRPC client sample has been added for F\#, demonstrating how to create a gRPC service client using the protobuf-net.Grpc.HttpClient library. The sample includes the necessary F\# code and Paket references to interact with a gRPC service.

sample/gRpcSample.Client · high confidence

A new gRPC sample project has been added to the repository, demonstrating how to implement a gRPC service using F\#. The sample includes a basic calculator service and showcases how to inject dependencies via the service constructor, specifically using a JSON serializer passed through the DI container. The project targets .NET 5.0 and includes the necessary F\# and gRPC-related dependencies.

sample/gRpcSample · medium confidence

The Saturn framework now supports gRPC services. Users can register gRPC endpoints using the new \use\_grpc\ builder method, which configures the necessary routing and dependency injection for gRPC services. This feature is supported on the netcoreapp3.1 target framework.

src/Saturn.Extensions.gRPC · high confidence

Added new benchmark projects for Giraffe, Saturn, and Saturn's Endpoint Router, each including a .NET 6.0 setup and a test script that uses wrk to measure performance. This allows users to compare the performance of these different routing and application setups.

benchmark · high confidence

A new sample application (Controller.Sample) is introduced to demonstrate advanced controller features. It showcases controller versioning (e.g., /users with version 1), controller embedding (e.g., /users/comments), and typed response handling (e.g., /typed returning JSON-like objects). The sample also includes a basic router configuration and depends on the Giraffe library.

sample/Controller.Sample · high confidence

A new sample project, ChannelsSample, has been added to demonstrate the framework's channel capabilities. It includes a F\# server implementation that handles WebSocket connections, processes messages, and broadcasts responses to clients. An accompanying HTML/JavaScript client is provided to test the WebSocket echo functionality and general message passing, serving as a practical example for users.

sample/ChannelsSample · high confidence

Adds a new \Saturn.AzureFunctions\ package that provides an abstraction for hosting Saturn applications on Azure Functions. The implementation exposes a \FunctionBuilder\ that configures routing, error handling, logging, and content negotiation (JSON/XML) for Azure Function endpoints, allowing developers to run their Saturn apps as serverless functions.

src/Saturn.AzureFunctions · high confidence

A new sample application is added to showcase the full capabilities of Saturn, including declarative routing, controller-based resource management, custom HTTP pipelines, static file serving, Gzip compression, and error handling. The sample demonstrates how to compose handlers, define API endpoints, and configure the application using the \application\ computation expression.

sample/Saturn.Sample · high confidence

The Saturn framework now provides a comprehensive set of modules to configure the application, define controllers, and manage real-time channels. The \Application\ module offers a computation expression for configuring the ASP.NET Core host, services, and middleware pipelines. The \Controller\ module introduces a functional MVC-style abstraction with support for standard REST actions (index, show, add, edit, create, update, patch, delete, delete\_all), sub-controllers, versioning, and action-specific plugs. Additionally, the \Channels\ module implements a WebSocket-based pub/sub system with a \SocketHub\ for broadcasting messages to connected clients. Authentication helpers for OAuth and JWT, along with CSRF protection and CORS support, are also included to secure the application.

src/Saturn · high confidence

The Saturn framework now includes a dedicated \Saturn.Extensions.Authorization\ library that provides convenient methods for integrating Google, GitHub, and Azure AD OAuth2 authentication, as well as generic OpenID Connect support. Developers can easily add these authentication schemes to their applications using the new \use\_google\_oauth\, \use\_github\_oauth\, \use\_azuread\_oauth\, and \use\_open\_id\_auth\_with\_config\ extension methods, which handle the necessary ASP.NET Core authentication and cookie configuration.

src/Saturn.Extensions.Authorization · high confidence

A new sample application demonstrating Windows authentication has been added to the repository. The sample, located in the sample/WindowsAuthSample directory, is built on .NET 5 and utilizes the Giraffe web server framework. It configures the application to use HTTP.sys for Windows authentication and includes standard middleware such as memory caching, GZip compression, and HTTPS redirection.

sample/WindowsAuthSample · high confidence

The project's build infrastructure has been modernized by replacing the legacy FAKE 4 build scripts (build.fsx, build.cmd, build.sh) with a new FAKE 5-based Build.fsx script. This change upgrades the .NET target framework to net6.0, as evidenced by the Build.fsx Publish target and the global.json SDK version 6.0.200. The migration also updates the FAKE dependencies to version 5 (e.g., Fake.DotNet.Cli, Fake.Core.Target) and removes the older Paket-based dependency management in favor of standard .NET tooling. Additionally, repository configuration files such as .editorconfig, .gitattributes, and .gitignore have been added or updated to enforce coding standards and manage version control behavior.

(repo-wide) · high confidence

Added a new \Saturn.UnitTests\ test suite covering the router, controller, and endpoint routing systems. The suite includes \RouterTests\ for basic HTTP method routing, \EndpointRouterTests\ for endpoint-based routing, \ControllerTests\ for controller actions and plug behavior, \LinksTests\ for link generation, and \BenchmarkTests\ for performance comparisons between Saturn and Giraffe. Helper functions in \Helpers.fs\ provide test context and response assertions.

tests · high confidence

The project has been upgraded to target .NET 6 (net6.0), replacing the previous .NET Framework 4.6.1 and .NET Core 3.1/5.0 targets. This change updates the build system to use the modern SDK-style project format, enabling features like implicit package references and simplified dependency management via Paket. All sample applications, benchmarks, and extension libraries have been migrated to .NET 6, ensuring compatibility with the latest ASP.NET Core features and performance improvements.

(dependencies) · high confidence

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

• CAI 50 → 51 (+1.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 89 → 86 (-3.1)
• Architecture 100 → 100 (+0.0)
• Maturity 41 → 41 (+0.0)
• Readiness 46 → 46 (+0.0)
• Security 54 → 63 (+9.7)

• Dependency hygiene not measured — no packages were read
• Duplicated block (11 lines × 2) (src/Saturn/RouterEndpoint.fs)
• Duplicated block (12 lines × 3) (src/Saturn/Common.fs)
• Duplicated block (14 lines × 2) (src/Saturn/ControllerEndpoint.fs)
• Duplicated block (15 lines × 2) (sample/TurbolinksSample/Views/OtherView.fs)
• Duplicated block (17 lines × 2) (src/Saturn/ControllerEndpoint.fs)
• Duplicated block (42 lines × 2) (src/Saturn/RouterEndpoint.fs)
• Duplicated block (5 lines × 2) (src/Saturn/ControllerHelpers.fs)
• Duplicated block (6 lines × 2) (sample/Saturn.Sample/Saturn.Sample.fs)
• Duplicated block (6 lines × 2) (src/Saturn/Application.fs)
• Duplicated block (6 lines × 2) (src/Saturn/Channels.fs)
• Duplicated block (7 lines × 2) (src/Saturn/ControllerEndpoint.fs)
• Duplicated block (8 lines × 2) (sample/Saturn.Sample/Saturn.Sample.fs)
• Duplicated block (8 lines × 2) (src/Saturn.Extensions.Authorization/OAuth.fs)
• Duplicated block (9 lines × 2) (src/Saturn.Extensions.Authorization/OAuth.fs)
• Duplicated block (9 lines × 2) (src/Saturn.Extensions.Authorization/OAuth.fs)
• Duplicated block (9 lines × 2) (src/Saturn.Extensions.Authorization/OAuth.fs)
• Duplicated block (9 lines × 2) (src/Saturn/Application.fs)
• Duplicated block (9 lines × 2) (src/Saturn/ControllerEndpoint.fs)
• Duplicated block (9 lines × 2) (src/Saturn/ControllerEndpoint.fs)
• …and 15 more

• Documentation: no contributor guidance (README.md)
• Duplicated block (10–11 lines × 2) (src/Saturn/Application.fs)
• Duplicated block (12 lines × 3) (src/Saturn/Common.fs)
• Duplicated block (16–17 lines × 2) (sample/TurbolinksSample/Views/Index.fs)
• Duplicated block (18 lines × 2) (src/Saturn/Common.fs)
• Duplicated block (20 lines × 2) (src/Saturn/Controller.fs)
• Duplicated block (22–26 lines × 2) (src/Saturn/Controller.fs)
• Duplicated block (4–9 lines × 3) (src/Saturn/Controller.fs)
• Duplicated block (5 lines × 2) (sample/EndpointRoutingSample/Program.fs)
• Duplicated block (5 lines × 2) (src/Saturn/Channels.fs)
• Duplicated block (52 lines × 2) (src/Saturn/Router.fs)
• Duplicated block (54 lines × 2) (src/Saturn/Router.fs)
• Duplicated block (6 lines × 2) (src/Saturn/Application.fs)
• Duplicated block (6 lines × 2) (src/Saturn/ControllerHelpers.fs)
• Duplicated block (6 lines × 2) (src/Saturn/Router.fs)
• Duplicated block (6 lines × 3) (src/Saturn/Controller.fs)
• Duplicated block (64 lines × 2) (src/Saturn/Controller.fs)
• Duplicated block (7 lines × 2) (src/Saturn.Extensions.Authorization/OAuth.fs)
• Duplicated block (7 lines × 2) (src/Saturn/Common.fs)
• Duplicated block (7 lines × 3) (src/Saturn.Extensions.Authorization/OAuth.fs)
• …and 31 more

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

SaturnFramework/Saturn 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.