F# PowerShell
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
.vscode Updated TaskBuilder.fs and ASP.NET Core packages Aug 15, 2018
samples Added new authorization handlers Aug 18, 2018
src/Giraffe Updated README and RELEASE_NOTES Aug 18, 2018
tests/Giraffe.Tests Added new authorization handlers Aug 18, 2018
.gitattributes Using TryAdd instead of Add in AddGiraffe Aug 15, 2018
.gitignore Added build.sh for making it easier to build on Linux/macOS Dec 2, 2017
.travis.yml .NET Core SDK installation script Aug 16, 2018
DOCUMENTATION.md Added documentation for new features Aug 18, 2018
Giraffe.sln Added .sln and build script improvements Aug 12, 2018
LICENSE Initial commit Jan 7, 2017
NuGet.config First alpha version + some tests Jan 8, 2017
README.md Added documentation for new features Aug 18, 2018
appveyor.yml Trying to circumvent AppVeyor global.json detection Aug 16, 2018
build.ps1 Updated TaskBuilder.fs and ASP.NET Core packages Aug 15, 2018
build.sh Fixed badges in README Dec 8, 2017
giraffe-64x64.png Uploaded new giraffe logo Apr 23, 2017
giraffe.png Changed logo with higher resolution version Apr 23, 2017
global.json Updated TaskBuilder.fs and ASP.NET Core packages Aug 15, 2018
install-dotnet.ps1 Removed parameter from Invoke-WebRequest Aug 16, 2018
jmeter-load-test.jmx Added Giraffe.Tasks as a dependency... Dec 12, 2017
nuget.ps1 Added PS script to find NuGet upgrades Aug 12, 2018
nuget.sh Added PS script to find NuGet upgrades Aug 12, 2018




A functional ASP.NET Core micro web framework for building rich web applications.

Read this blog post on functional ASP.NET Core for more information.

NuGet Info

Windows Linux
Build status Linux Build status
Windows Build history Linux Build history

Table of contents


Giraffe is an F# micro web framework for building rich web applications. It has been heavily inspired and is similar to Suave, but has been specifically designed with ASP.NET Core in mind and can be plugged into the ASP.NET Core pipeline via middleware. Giraffe applications are composed of so called HttpHandler functions which can be thought of a mixture of Suave's WebParts and ASP.NET Core's middleware.

If you'd like to learn more about the motivation of this project please read my blog post on functional ASP.NET Core (some code samples in this blog post might be outdated today).

Who is it for?

Giraffe is intended for developers who want to build rich web applications on top of ASP.NET Core in a functional first approach. ASP.NET Core is a powerful web platform which has support by Microsoft and a huge developer community behind it and Giraffe is aimed at F# developers who want to benefit from that eco system.

It is not designed to be a competing web product which can be run standalone like NancyFx or Suave, but rather a lean micro framework which aims to complement ASP.NET Core where it comes short for functional developers. The fundamental idea is to build on top of the strong foundation of ASP.NET Core and re-use existing ASP.NET Core building blocks so F# developers can benefit from both worlds.

You can think of Giraffe as the functional counter part of the ASP.NET Core MVC framework.

Getting Started

Using dotnet-new

The easiest way to get started with Giraffe is by installing the giraffe-template package, which adds a new template to your dotnet new command line tool:

dotnet new -i "giraffe-template::*"

Afterwards you can create a new Giraffe application by running dotnet new giraffe.

If you are using dotnet core 2.1.4, you will need to specify the language: dotnet new giraffe -lang F#

For more information about the Giraffe template please visit the official giraffe-template repository.

Doing it manually

Install the Giraffe NuGet package:

PM> Install-Package Giraffe

Create a web application and plug it into the ASP.NET Core middleware:

open Giraffe

let webApp =
    choose [
        route "/ping"   >=> text "pong"
        route "/"       >=> htmlFile "/pages/index.html" ]

type Startup() =
    member __.ConfigureServices (services : IServiceCollection) =
        // Register default Giraffe dependencies
        services.AddGiraffe() |> ignore

    member __.Configure (app : IApplicationBuilder)
                        (env : IHostingEnvironment)
                        (loggerFactory : ILoggerFactory) =
        // Add Giraffe to the ASP.NET Core pipeline
        app.UseGiraffe webApp

let main _ =

Instead of creating a Startup class you can also add Giraffe in a more functional way:

open Giraffe

let webApp =
    choose [
        route "/ping"   >=> text "pong"
        route "/"       >=> htmlFile "/pages/index.html" ]

let configureApp (app : IApplicationBuilder) =
    // Add Giraffe to the ASP.NET Core pipeline
    app.UseGiraffe webApp

let configureServices (services : IServiceCollection) =
    // Add Giraffe dependencies
    services.AddGiraffe() |> ignore

let main _ =
        .Configure(Action<IApplicationBuilder> configureApp)

For more information please check the official Giraffe documentation.

Sample applications

Demo apps

There is a few sample applications which can be found in the /samples folder:

Sample Description
GoogleAuthApp Demonstrates how Google Auth can be used with Giraffe.
IdentityApp Demonstrates how ASP.NET Core Identity can be used with Giraffe.
JwtApp Demonstrates how JWT tokens can be used with Giraffe.
SampleApp Generic sample application showcasing multiple features such as file uploads, cookie auth, model binding and validation, etc.

Live apps


The web service https://buildstats.info uses Giraffe to build rich SVG widgets for Git repositories. The application runs as a Docker container in the Google Container Engine (see CI-BuiltStats on GitHub for more information).

More sample applications will be added in the future.


Currently Giraffe has only been tested against a simple plain text route and measured the total amount of handled requests per second. The latest result yielded an average of 79093 req/s over a period of 10 seconds, which was only closely after plain Kestrel which was capable of handling 79399 req/s on average.

Please check out Jimmy Byrd's dotnet-web-benchmarks for more details.

Building and developing

Giraffe is built with the latest .NET Core SDK.

You can either install Visual Studio 2017 which comes with the latest SDK or manually download and install the .NET SDK 2.1.

After installation you should be able to run the .\build.ps1 script to successfully build, test and package the library.

The build script supports the following flags:

  • -IncludeTests will build and run the tests project as well
  • -IncludeSamples will build and test the samples project as well
  • -All will build and test all projects
  • -Release will build Giraffe with the Release configuration
  • -Pack will create a NuGet package for Giraffe and giraffe-template.
  • -OnlyNetStandard will build Giraffe only targeting the NETStandard1.6 framework


Only build the Giraffe project in Debug mode:

PS > .\build.ps1

Build the Giraffe project in Release mode:

PS > .\build.ps1 -Release

Build the Giraffe project in Debug mode and also build and run the tests project:

PS > .\build.ps1 -IncludeTests

Same as before, but also build and test the samples project:

PS > .\build.ps1 -IncludeTests -IncludeSamples

One switch to build and test all projects:

PS > .\build.ps1 -All

Build and test all projects, use the Release build configuration and create all NuGet packages:

PS > .\build.ps1 -Release -All -Pack

Building on Linux or macOS

In order to successfully run the build script on Linux or macOS you will have to install PowerShell for Linux or Mac.

Additionally you will have to install the latest version of Mono and execute the ./build.sh script which will set the correct FrameworkPathOverride before subsequently executing the ./build.ps1 PowerShell script.

Development environment

Currently the best way to work with F# on .NET Core is to use Visual Studio Code with the Ionide extension. Intellisense and debugging is supported with the latest versions of both.


Help and feedback is always welcome and pull requests get accepted.


  • First open an issue to discuss your changes
  • After your change has been formally approved please submit your PR against the develop branch
  • Please follow the code convention by examining existing code
  • Add/modify the README.md as required
  • Add/modify unit tests as required
  • Please document your changes in the upcoming release notes in RELEASE_NOTES.md
  • PRs can only be approved and merged when all checks succeed (builds on Windows and Linux)

Discuss your change first

When contributing to this repository, please first discuss the change you wish to make via an open issue before submitting a pull request. For new feature requests please describe your idea in more detail and how it could benefit other users as well.

Please be aware that Giraffe strictly aims to remain as light as possible while providing generic functionality for building functional web applications. New feature work must be applicable to a broader user base and if this requirement cannot be sufficiently met then a pull request might get rejected. In the case of doubt the maintainer might rather reject a potentially useful feature than adding one too many. This measure is to protect the repository from feature bloat and shall not be taken personally.

Code conventions

When making changes please use existing code as a guideline for coding style and documentation. For example add spaces when creating tuples ((a,b) --> (a, b)), annotating variable types (str:string --> str : string) or other language constructs.


let someHttpHandler:HttpHandler =
    fun (ctx:HttpContext) next -> task {
        // Some work

should be:

let someHttpHandler : HttpHandler =
    fun (ctx : HttpContext) (next : HttpFunc) ->
        task {
            // Some work

Keep documentation and unit tests up to date

If you intend to add or change an existing HttpHandler then please update the README.md file to reflect these changes there as well. If applicable unit tests must be added or updated and the project must successfully build before a pull request can be accepted.

Submit a pull request against develop

The develop branch is the main and only branch which should be used for all pull requests. A merge into develop means that your changes are scheduled to go live with the very next release, which could happen any time from the same day up to a couple weeks (depending on priorities and urgency).

Only pull requests which pass all build checks and comply with the general coding guidelines can be approved.

If you have any further questions please let me know.

You can file an issue on GitHub or contact me via https://dusted.codes/about.

Nightly builds and NuGet feed

All official Giraffe packages are published to the official and public NuGet feed.

Unofficial builds (such as pre-release builds from the develop branch and pull requests) produce unofficial pre-release NuGet packages which can be pulled from the project's public NuGet feed on AppVeyor:


If you add this source to your NuGet CLI or project settings then you can pull unofficial NuGet packages for quick feature testing or urgent hot fixes.

Please be aware that unofficial builds have not gone through the scrunity of offical releases and their usage is on your own risk.

Blog posts

Blog posts by author

Community blog posts

If you have blogged about Giraffe, demonstrating a useful topic or some other tips or tricks then please feel free to submit a pull request and add your article to this list as a reference for other Giraffe users. Thank you!



Apache 2.0

Contact and Slack Channel

If you have any further questions feel free to reach out to me via any of the mentioned social media on https://dusted.codes/about or join the #giraffe Slack channel in the Functional Programming Slack Team. Please use this link to request an invitation to the Functional Programming Slack Team if you don't have an account registered yet.