by ionide

ionide / Fornax

Scriptable static site generator using type safe F# DSL to define page templates.

158 Stars 32 Forks Last release: 6 months ago (0.13.1) MIT License 188 Commits 8 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:



Fornax is a scriptable static site generator using type safe F# DSL to define page layouts.

Fornax is part of Ionide tooling suite - You can support its development on Open Collective.

open collective backers open collective sponsors

Open Collective

Working features

  • Creating custom data loaders using
    files, meaning you can use as a source of data for your site anything you can imagine, not only predefined
  • Creating custom generators using
    files, meaning you can generate any type of output you want
  • Dynamic configuration using
  • Watch mode that rebuilds your page whenever you change data, or any script file.


Fornax is released as a global .Net Core tool. You can install it with

dotnet tool install fornax -g

CLI Application

The main functionality of Fornax comes from CLI applications that lets user scaffold, and generate webpages.

  • fornax new
    - scaffolds new blog in current working directory using really simple template
  • fornax build
    - builds webpage, puts output to
  • fornax watch
    - starts a small webserver that hosts your generated site, and a background process that recompiles the site whenever any changes are detected. This is the recommended way of working with Fornax.
  • fornax clean
    - removes output directory and any temp files
  • fornax version
    - prints out the currently-installed version of Fornax
  • fornax help
    - prints out help

Getting started

Easiest way to get started with

is running
fornax new
and then
fornax watch
- this will create fairly minimal blog site template, start
in watch mode and start webserver. Then you can go to the
in your browser to see the page, and edit the scaffolded files in editor to make changes. Additionally, you can take a look at
folder in this repository - it have couple more
that you can potentially use in your website.

Website definition

Fornax is using normal F# code (F# script files) to define any of it's core concepts:



is fairly simple type that provides access to any information available to the Fornax. The information is put into it by using
and then can be accessed in the

has several functions in it's public API:
type A = {a: string}
type B = {b: int; c: int}

let sc = SiteContents() sc.Add({a = "test"}) sc.Add({a = "test2"}) sc.Add({a = "test3"})

sc.Add({b = 1; c = 3}) //You can add objects of different types, Add method is generic.

let as = sc.TryGetValues() //This will return option of sequence of all added elements for given type - in this case it will be 3 elements let b = sc.TryGetValue() //This will return option of element for given type


is an F# script responsible for loading external data into generation context. The data typically includes things like content of
files, some global site configuration, etc. But since those are normal F# functions, you can do whatever you need. Want to load information from local database, or from internet? Sure, why not. Want to use World Bank TP to include some of the World Bank statistics? That's also possible - you can use in
any dependency as in normal F# script.

are normal F# functions that takes as an input
and absolute path to the page root, and returns
#r "../_lib/Fornax.Core.dll"

type Page = { title: string link: string }

let loader (projectRoot: string) (siteContent: SiteContents) = siteContent.Add({title = "Home"; link = "/"}) siteContent.Add({title = "About"; link = "/about.html"}) siteContent.Add({title = "Contact"; link = "/contact.html"})


Important note: You can (and probably should) define multiple loaders - they will all be executed before generation of site, and will propagate information into



is an F# script responsible for generating output of the Fornax process. This is usually
file, but can be anything else - actually
API just requires to return
that will be saved to file. Generators are, again, plain F# functions that as an input takes
, absolute path to the page root, relative path to the file that's currently processed (may be empty for the global generators) and returns
#r "../_lib/Fornax.Core.dll"
#load "../loaders/postloader.fsx"

open Html

let generate' (ctx : SiteContents) (_: string) = let posts = ctx.TryGetValues<> () |> Option.defaultValue Seq.empty

let psts =
    |&gt; Seq.toList
    |&gt; (fun p -&gt; span [] [!!] )

html [] [
    div [] psts

let generate (ctx : SiteContents) (projectRoot: string) (page: string) = generate' ctx page |> HtmlElement.ToString </>

Important note: You can (and probably should) define multiple generators - they will generate different kinds of pages and/or content, such as



is a F# script file that defines when which analyzers need to be run, and how to save its output.
file needs to be put in the root of your site project (the place from which you run
CLI tool)
#r "../_lib/Fornax.Core.dll"

open Config open System.IO

let postPredicate (projectRoot: string, page: string) = let fileName = Path.Combine(projectRoot,page) let ext = Path.GetExtension page if ext = ".md" then let ctn = File.ReadAllText fileName ctn.Contains("layout: post") else false

let staticPredicate (projectRoot: string, page: string) = let ext = Path.GetExtension page if page.Contains "_public" || page.Contains "_bin" || page.Contains "_lib" || page.Contains "_data" || page.Contains "_settings" || page.Contains "_config.yml" || page.Contains ".sass-cache" || page.Contains ".git" || page.Contains ".ionide" || ext = ".fsx" then false else true

let config = { Generators = [ {Script = "less.fsx"; Trigger = OnFileExt ".less"; OutputFile = ChangeExtension "css" } {Script = "sass.fsx"; Trigger = OnFileExt ".scss"; OutputFile = ChangeExtension "css" } {Script = "post.fsx"; Trigger = OnFilePredicate postPredicate; OutputFile = ChangeExtension "html" } {Script = "staticfile.fsx"; Trigger = OnFilePredicate staticPredicate; OutputFile = SameFileName } {Script = "index.fsx"; Trigger = Once; OutputFile = NewFileName "index.html" }



How to contribute

Imposter syndrome disclaimer: I want your help. No really, I do.

There might be a little voice inside that tells you you're not ready; that you need to do one more tutorial, or learn another framework, or write a few more blog posts before you can help me with this project.

I assure you, that's not the case.

This project has some clear Contribution Guidelines and expectations that you can read here.

The contribution guidelines outline the process that you'll need to follow to get a patch merged. By making expectations and process explicit, I hope it will make it easier for you to contribute.

And you don't just have to write code. You can help out by writing documentation, tests, or even by giving feedback about this work. (And yes, that includes giving feedback about the contribution guidelines.)

Thank you for contributing!

Build process

  • You need .NET Core 3.0 SDK
  • Run
    dotnet tool restore
    to restore the .NET Core 3 local tools defined at .config/dotnet-tools.json
  • To build the project run
    dotnet fake build
  • To run unit tests run
    dotnet fake build -t Test

Contributing and copyright

The project is hosted on GitHub where you can report issues, fork the project and submit pull requests. Please read Contribution Guide

The library is available under MIT license, which allows modification and redistribution for both commercial and non-commercial purposes.

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.