dbrattli/Fable.Giraffe

This system is a multi-target web framework that compiles F\# code to run on Python, JavaScript/Node, and BEAM (Erlang) runtimes. It provides a unified API for routing, static file serving, and typed JSON serialization, ensuring consistent behavior across all supported platforms. The framework includes built-in support for OpenAPI 3.1 documentation generation and hosts Model Context Protocol (MCP) tools. A shared test suite and benchmarking harness verify functional parity and performance across the different backends.

5 changes.

The project was initialized with a multi-target F\# web framework supporting Python, JavaScript, and BEAM backends, establishing core build infrastructure and dependency manifests. Key features introduced include an opt-in OpenAPI 3.1 endpoint layer for typed JSON and documentation, alongside a sample application demonstrating MCP tool hosting and static file serving.

9 changes.

The project introduced new BEAM (Erlang/OTP) and JavaScript/Node.js backends to extend the Giraffe framework beyond its existing targets. These additions were accompanied by a unified testing infrastructure using Scriptorium to ensure consistent behavioral validation across all platforms, along with a benchmark harness for cross-target performance comparison.

A new public HTML entry point (index.html) has been added to the application, providing a basic landing page styled with Bulma CSS that displays the title 'NDC { Oslo }' and a subtitle referencing Fable Giraffe.

app/public · high confidence

A new benchmarking suite has been added to the \perf\ directory to provide fair, reproducible throughput comparisons across all supported runtime targets (dotnet, python, js, beam). The harness uses a shared \bench.sh\ script to build and run minimal applications serving an identical \/ping\ handler on each target, driving load with \oha\ while ensuring logging is disabled to prevent performance skew. This allows users to compare the raw framework performance of the Fable-compiled targets against the native .NET Giraffe reference implementation.

perf · high confidence

A new BEAM-based backend is introduced in app/beam, providing a web server powered by Fable.Giraffe. This implementation exposes a set of sample endpoints (ping, json, greet, mcp) and integrates OpenAPI 3.1 documentation generation, ensuring the spec is rendered as an immutable string to remain compatible with Cowboy's per-request process model. The server also supports serving static files from the app/public directory and includes configured logging.

app/beam · high confidence

A new JavaScript/Node backend entry point (app/js/Program.fs) has been added, establishing a web server on port 8080 using the Fable.Giraffe framework. This backend serves static files from the /static path, exposes API endpoints for health checks (/ping), JSON data (/json), request echoing (/echo), and MCP tool hosting (/mcp), and includes debug logging capabilities.

app/js · high confidence

The repository is initialized with the core project structure, including a solution file defining Python, JavaScript, and BEAM targets, a Justfile for build and test orchestration, and a rebar.config for the BEAM backend. Documentation is added via a CHANGELOG tracking versions from 0.12.0 to 5.5.0, a CLAUDE.md detailing the architecture and JSON/Remoting implementation, and a RELEASING.md outlining the ShipIt automation. A .editorconfig standardizes formatting for F\# and TypeScript files, and a uv.lock pins Python dependencies.

(repo-wide) · high confidence

Adds a new BEAM (Erlang/OTP) target for Giraffe, enabling hosting on the BEAM runtime via the Cowboy web server. This implementation provides a full HTTP stack including request/response context, middleware pipeline, and dependency injection, while introducing Fable.TypedJson for consistent, type-safe serialization and OpenAPI schema generation across all backends. It also includes static file serving, per-request access logging, and portable service container handling to support embedding in existing Erlang applications.

src/beam · high confidence

This change adds a new JavaScript/Node.js target to the Giraffe web framework, enabling F\# applications to run on Node.js via Fable. It introduces a complete backend implementation including an \HttpContext\ that wraps Node's native HTTP objects, a \Server\ module that exposes the application as Connect/Express-compatible middleware or a standalone server, and a \WebHostBuilder\ for configuration. The backend integrates \Fable.TypedJson\ for consistent, type-safe JSON serialization and schema generation across all platforms, and includes static file serving support via \serve-static\.

src/js · high confidence

Adds a new \Endpoints\ module that provides a describable routing layer, allowing developers to define routes with metadata (summary, tags, operation IDs) and explicit request/response types for automatic OpenAPI 3.1 documentation generation. This layer sits alongside the existing classic handler composition, offering an opt-in way to build APIs with built-in schema validation and documentation capabilities via \Fable.TypedJson\.

src · high confidence

The app directory now contains a complete F\# web application (Program.fs) that serves static files, exposes typed JSON endpoints, and includes structured logging via Structlog. It features an opt-in OpenAPI 3.1 documentation layer for its API routes and hosts a typed MCP (Model Context Protocol) tool example (McpExample.fs) that is shared across Python, JavaScript, and BEAM backends. A .gitignore file for Python artifacts is also added.

app · high confidence

The Python backend has been updated to run on the ASGI interface, introducing a new middleware layer that bridges Giraffe handlers to ASGI applications. This change enables serving static files via Starlette's StaticFiles and implements typed JSON serialization and deserialization using Fable.TypedJson, ensuring consistent field naming and schema generation across backends.

src/python · high confidence

Add BEAM test suite runner and test context; Added JavaScript and Python test runners using Scriptorium; Migrate shared test suite to Scriptorium.

This change introduces the build manifests (\.fsproj\ files) and dependency lockfiles (\package-lock.json\, \pyproject.toml\) for the Fable.Giraffe library and its associated test and performance suites. It establishes the dependency graph for the three supported backends—Python (Starlette), JavaScript/Node (Express/serve-static), and BEAM (Cowboy)—pinning specific versions for Fable.Core, Fable.TypedJson, and platform-specific runtimes. It also configures the .NET 8.0 target framework and the Scriptorium testing framework (Quill + Nib) for the shared test suite.

(dependencies) · high confidence

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

• CAI 70 → 70 (+0.1)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 94 → 94 (+0.0)
• Architecture 95 → 96 (+1.3)
• Maturity 67 → 67 (+0.0)
• Readiness 65 → 65 (+0.0)
• Security 71 → 71 (+0.2)

• Documentation: no usage examples (README.md)
• Hotspot: src/Mcp.fs (src/Mcp.fs)

• Critical CVE: [GHSA redacted] (uv.lock)

• 5 commits — 5 feature/other, 0 fixes

• (root) — 3 commits
• .config/dotnet-tools.json — 2 commits

• change: chore(deps): Bump fable-library in the python-prod group (#106)
• change: chore(deps): Bump starlette from 1.6.0 to 1.7.0 in the python-prod group (#108)
• change: chore(deps-dev): Bump the python-dev group with 2 updates (#105)
• change: chore: Bump the nuget group with 2 updates (#107)
• change: chore: Bump the nuget group with 3 updates (#109)

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

dbrattli/Fable.Giraffe 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.