Lightweight websites with F#

There are several common approaches I’ve seen people take on the .NET platform when writing web-based applications that I want to review in terms of language and framework choice: –

  • Adopt a conventional MVC application approach. Write static HTML that is emitted from the server using e.g. Razor markup + C# / VB .NET, write your controllers and any back-end logic in C#.
  • As above, but replace your back-end logic with F#. This is a reasonable first step to take, because essentially all your data access “back-end” processing are performed in a language that it’s best suited for, whilst your C# is relegated to essentially thin controllers and some simple markup logic.
  • Adopt a “SPA”-style approach. But this I mean split your web application into two distinct applications – a client-side application that is self-managing, typically using Javascript and some framework like Knockout or AngularJS; meanwhile your back-end is a hosted WebAPI written in F#.
  • Write the entire application in F#. Surely you can’t write websites in F# can you? Well, actually, there are some (pretty sophisticated) frameworks like WebSharper out there that can do that, rewriting your F# into e.g. Typescript and the like.

I haven’t used WebSharper in depth so can’t comment on the effectiveness of writing your client-side code in F# and therefore not going to talk about the latter option today. but I have written WebAPIs in F# and want to talk about where I do think your separation of concerns should lie with respect to client and server side code.

As far as I’m concerned, if you’re a .NET developer today, writing websites, then you should be writing as much as of the CLR-side code as possible in F#. I am really pleased with the brevity that you can get from the combination of OWIN, Katana (Microsoft’s web-hosting OWIN framework), Web API and F#. This combination will allow you to create Web APIs that can be created simply and easily, and when combined with a SPA client-side website is a compelling architectural offering.

Sudoku in F#

Some months ago, I wrote a Sudoku solver in F# (I think that there’s a gist somewhere with the implementation). I wanted to try to write a website on top of it with a visual board that allowed you to quickly enter a puzzle and get the solution back. So, having borrowed some HTML and CSS from an existing website, I set about doing it. You can see the finished site here and the source code is here.



  • HTML
  • AngularJS
  • Typescript (no native Javascript please!)


  • F#
  • F#
  • F#

Standard JSON is used to pass data between website and server. On the server side, we use OWIN, Katana and Web API to handle the web “stuff”. This then ties into the real processing with the minimum of effort. This was all done in a single solution and a single F# project.

OWIN with F#

I’m no Angular or Typescript expert so I’m not going to focus on it – suffice it to say that Typescript is a massive leap over standard Javascript whilst retaining backwards compatibility, and AngularJS is a decent MVC framework that runs in Javascript. What I’m more interested in talking about is how to host and run the entire site through a single F# project. Mark Seeman‘s excellent blog has already discussed creating ASP .NET websites through F#, and there are indeed some templates that you can download for Visual Studio that enable this. However, they still use ASP .NET and the full code-bloat that it comes with. Conversely, using OWIN and Katana, this all goes away. What I like about OWIN is that there’s no code-generation, no uber folder hierarchies or anything like that, you have full control over the request / response pipeline, plus you get the flexibility to change hosting mechanisms extremely easily. To startup, all we need is to download a (fair) few NuGet packages, and then create a Startup class with a Configuration method: –

open System.Web.Http
open Newtonsoft.Json.Serialization
open global.Owin
type Config = {
id : RouteParameter
type Startup() =
member __.Configuration(app:IAppBuilder) =
let config =
let config = new HttpConfiguration()
config.Formatters.Remove config.Formatters.XmlFormatter |> ignore // optional - don't emit data as XML
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver <- DefaultContractResolver() // optional - use the JSON serializer for F# types etc.
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", { id = RouteParameter.Optional }) |> ignore // set up default web api route
app.UseWebApi config |> ignore // turn on Web API!
view raw owinstartup.fs hosted with ❤ by GitHub

Now you have that you can simply create Web API controllers: –

type ExampleRequest =
{ Name : string
Age : int }
type ExampleController() =
inherit ApiController()
/// Maps to HTTP GET.
member __.Get(id : string) =
sprintf "Hello %s from F#!" id
/// Maps to HTTP POST.
member __.Post(request : ExampleRequest) =
async {
return match request.Age with
| 18 -> "You are 18!"
| _ -> "You are not 18!"
} |> Async.StartAsTask // can easily make asynchronous controller methods.
view raw webapicontroller.fs hosted with ❤ by GitHub

So two F# files, a web.config and you’re good to go from a server-side point of view. Talking of web.config – how do you create an F# web project? Mark Seeman’s blog gives full details on creating Visual Studio web projects that are F# compliant, but essentially just adding the “Project Type” GUID in the .fsproj file (I think it’s 349C5851-65DF-11DA-9384-00065B846F21) will do the job.

Combining client and server side assets

UntitledBecause this is a full .NET web project you can do all the things that you would normally do in C# web projects, such as serve up static files (perfect for a SPA) like HTML, Javascript and CSS, as well as generating from Typescript files (just add an project import for the Typescript msbuild target). If you appreciate the extra security you get from F# over other statically typed .NET languages, you’ll almost certainly want to use Typescript over raw Javascript as well, so this should be a given.

A single project that can serve up your web assets and the server side logic to go with it looks pretty simple – in this screenshot, in the api folder is my back-end logic – message contracts between client and server, the actual puzzle solver and the Web API controller.

Client side assets are few and far between – just a SudokuController.ts to hold the controller logic and Index.HTML + stylesheet for the presentation layer. It’s important to note that with a SPA framework like AngularJS, you serve static HTML and Javascript; the Javascript then essentially bootstraps, modifying the HTML dynamically, requesting JSON from the WebAPI and occasionally getting more static HTML. You never modify HTML on the server as you would do with something like Razor.

In addition, as it’s a “normal” website, with Visual F# 3.1.2, you can use Azure websites to deploy this easily – either through VS to manually publish out to Azure, or through Azure’s excellent source control integration to e.g. GitHub or BitBucket webhooks. It’s never been easier to get a CI deploy of a website out.

More flexibility with Web API

Another important thing about Owin is that it separates out the hosting element of the website from the actual project structure. So, after talking about all this nice website project integration, there’s actually nothing to stop you creating a standard F# library project, and then use either the Owin WebHost console application (available over NuGet), or create an empty website or Azure worker and then host it through that via the Owin Host. All this can be done without making any changes to your actual configuration class or actual controllers.


A common misconception around F# is that it’s great for use as a “computation engine” where you give it a number and it gives you back another number. Or perhaps a “data processing engine” where it can read some data from a flat file or a web service and do something to it. These are both true – however, there is very little reason why you can’t use it for full featured Web APIs using Owin (as there’s no code generation to miss out on from e.g. VS/C# projects), and with a minimum amount of effort, even as a full website host for a SPA that will consume that same Web API.

In my next post I want to replace the use of Typescript with F# using Funscript to illustrate how you can have a fully-managed end to end solution for both client and server in F#.

16 thoughts on “Lightweight websites with F#

  1. Thanks for the excellent leg up in building a pure F# web app. Now how about some tips for persisting to a database? I’m keen to discover how F# can do it all 🙂

    1. Now I read on I see the Azure Storage Type provider – fantastic. I watched your Skills Matter presentation but still struggling & would really be helped by an example of the SPA using the Type provider to persist into storage?

  2. Hi, Can you say how you created the solution/project. Say starting from an “F# Web API” template. I’m having trouble setting up a TS+F# project.

    1. Hi Samin. All the source code is available on BitBucket – there’s a link in the post – and from there you should be able to see how the project was created. Let me know if you have any more specific questions.

      1. Hi Isaac, Thanks for point me to the source. I can build that fine. But: I can’t seem to modify that project easily. If use VS to add a angular\Test.ts file, for instance, then the build complains:

        F:\sudoku-solver\src\SudokuSolver.fsproj : error : The project ‘SudokuSolver.fsproj’ could not be opened because opening it would cause a folder to be rendered multiple times in the solution explorer. One such problematic item is ‘angular\Test.ts’. To open this project in Visual Studio, first edit the project file and fix the problem.

        If I manually edit .fsproj to make it look like the current angular\SudokuController.ts, then things build OK.

        Any hints? I’m on VS2013/Windows 8.

      2. That’s an issue with the VS project system along with the F# Power Tools which is used to create folder structures. Basically after adding your new file and seeing this error, if you open up the .fsproj file in notepad you’ll see that the files in the “angular” folder are spread across the project file list. If you move them so that the new file lies directly next to the existing files in the angular folder, you’ll see the error goes away.

      3. Yes, that’s what happening and that’s how I fixed it. I think it’ll work for me for now— thanks!
        My original question was how you set up this solution. Did you start from an Empty project, an F# Web API one, or what? (As in: if I didn’t have your project to clone, how would I go about setting up the project? Apart from editing the fsproj by hand!)

      4. Thanks, that’s good advice of yours: to just use F# Web API 2. I want to get a web app up and running, using Typescript for the frontend and F# for the backend. I don’t want to edit the .fsproj by hand every time I add a file!

      5. Yeah. If you don’t use folders then the issue doesn’t appear though. You could also look at e.g. Creating a standard F# library and creating a separate project to host it.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s