Ultimate List of Static Site Generators

On this page we will display the ultimate list of static site generators. For those of you who are interested in this theme, the writing that we present is perfect for you.

What is a static site generator?

As websites grew to deliver more and more content, the web development industry found new ways to make the process of maintaining and updating sites more efficient. Years ago, we saw a move away from creating large numbers of individual files by hand, to a system where repeated sections of code could be included and repeated more easily. Web servers would perform that task on demand whenever a request for a resource was received. They’d faithfully combine templates and content, apply loops and logic, and return a page view whenever one was requested. And we’d have to ensure that they had enough horsepower to keep up with demand, fearing the times that our site became popular!

Static site generators (SSG) do much the same thing. They apply data and content to templates, and generate a view of a page which can be served to the visitors of a site.

The greatest difference between a static site generator and a traditional web application stack, is that instead of waiting until a page is requested and then generating its view on demand each time, a static site generator does this in advance so that the view is ready to serve ahead of time. And it does so for every possible view of a site at build time.

Source: Netlify.com


Why use a static site generator?

There are many advantages to site which are built this way. Perhaps the most significant of them are:

  • Security
  • Scale
  • Performance


How to find the best static site generator

“Ok, I’m convinced. Which is the best one?”

There are a number of key considerations when looking for the best static site generator for you and your next project. Let’s look at 3 of the most important ones.

  1. What are you building?  At the heart of choosing the right tool is considering the job you need to do with it. Ensuring the the output of the site generator delivers the best possible experience for the users of your site is important to consider.
  2. How are you building? Following what you are building, perhaps the next most important consideration is how you are hoping to build. Ensuring an effective and efficient development experience can have a big influence on success.
  3. How complex are your templating needs? The type of variety and complexity in the site you are creating could well influence the templating tools you’ll want at your disposal.

Source: Netlify.com

This page contains a long list of static site generators from various programming languages. We will always update this list when we find the latest data about it. If you feel this page is incomplete. You can find a long list of static site generators and study them at staticgen.com. Many of them are linked to sample project templates that you can use to quickly clone and apply sample projects to Netlify to help you start experimenting in no time.

Happy reading …


Ultimate List of Static Site Generators

. Net


http://wyam.io https://github.com/Wyamio/Wyam(1080) Languages:.Net Templates:Razor, Markdown License:MIT   Wyam is a static content generator and can be used to generate web sites, produce documentation, create ebooks, and much more. Since everything is configured by chaining together flexible modules (that you can even write yourself), the only limits to what it can create are your imagination.   Features

  • Written in .NET and easily extensible
  • Low ceremony – download a zip file, unzip, and run
  • Flexible script-based configuration using the power of the .NET Compiler Platform (Roslyn)
  • Lots of modules for things like reading and writing files, handling frontmatter, and manipulating metadata
  • YAML parser
  • Less CSS compiler
  • Support for multiple templating languages including Razor
  • Integrated web server for previewing output
  • Integrated file watching and regeneration
  • Full NuGet support
  • Embeddable engine0


http://code52.org/pretzel.html https://github.com/Code52/pretzel (571) Languages:.Net Templates:Liquid License:Microsoft A simple, pluggable site generation tool for .NET developers and Windows users (with Mono support planned I think) Pretzel follows the same convensions as Jekyll and should be compatible with basic Jekyll websites. If you are not familiar with Jekyll, have a read at: https://github.com/mojombo/jekyll/wiki/Usage


http://mikaelkoskinen.net/graze-static-site-generator-using-razor https://github.com/mikoskinen/graze(108) Languages:.Net Templates:Razor License:MIT   Graze is a static site generator. It takes a template and a configuration file and generates a static web site. The generated site is pure HTML / CSS / JavaScript and can be hosted on any web server. The Graze templates are created using the Razor Syntax.

Misakai Baker

http://baker.misakai.com https://github.com/kelindar/misakai-baker (41)   Languages:.Net Templates:Razor License:Apache 2.0   The aim of this project is to write a flexible and extensible static website generator for C# / .Net people. Misakai Baker uses a combination of Markdown and Yaml headers and Razor templates to produce clean code separation. Current binaries can be found here: misakai-baker.zip   Features

  • Combine Markdown + Razor view engine, layouts, sections and helpers
  • Jekyll-like headers for the model
  • Various optimizations: HTML minifier, CSS minifier, JavaScript minifier and PNG optimizer
  • Pipeline model for processors and various combinations
  • Yaml configuration file
  • Integrated web server for testing
  • File watcher and live reload for development cycle updates


https://github.com/wkallhof/iron-beard https://github.com/wkallhof/iron-beard(14) Languages:.Net Templates:Razor, Markdown License:MIT   A simple and easy to use cross-platform static site generator built with .NET Core. IronBeard processes your Razor .cshtml files and markdown .md files into full .html files ready for static hosting on services like Amazon S3. IronBeard maintains your folder structure and copies static assets like images, JS, and CSS into their respective directories to maintain the correct linking on the generated site. Adding a beard.json file to your project root allows for further configuration.   Features

  • Support for recursive folder and file structures
  • Markdown Processor
  • Razor Processor
  • Static File Processor
  • Razor Layout Support (wraps other razor files and markdown markup)
  • Markdown metadata (YAML Frontmatter support in markdown)
  • Razor metadata (YAML Frontmatter support with Razor comments)
  • HTML Formatting to clean up file output.
  • URL correction (properly handles relative routes and root folder routing (index.html etc.))
  • Global configuration file
  • Rich CLI output
  • Valid system errors codes (useful for automation)
  • Watch command for automatic rebuilding on file or directory change



https://yet-another-static-site-generator.github.io https://github.com/yet-another-static-site-generator/yass (1) Languages:Ada Templates:Ada License:GNU GPL v3.0   Yass stands for Yet Another Static Site (Generator) from CommonMark files.  Features:

  • Advanced Ada Web Server HTML templates
  • Full CommonMark support via libcmark
  • Can be extended with modules, written in any script/programming language
  • Can generate sitemaps
  • Can generate Atom feeds




http://github.com/nuex/zodiac https://github.com/nuex/zodiac (173) Languages:Awk Templates:Custom License:MIT   Zodiac is a static website generator that uses existing tools like awk, sh, find, cp, etc., to generate a static website. Zodiac is small, fast and sports a simple templating system and the ability to customize output using helpers written in awk.



  https://github.com/Jack000/Expose https://github.com/Jack000/Expose (4071) Languages:Bash Templates:HTML License:MIT   Expose is a Bash script that turns images and videos in a folder into a photoessay similar to jack.ventures or jack.works (the authors personal blogs). If you’re not a fan of that look, a Medium-style theme is included. The only dependency is Imagemagick. For videos FFmpeg is also required.


https://github.com/cfenollosa/bashblog https://github.com/cfenollosa/bashblog (840) Languages:Bash Templates:None License:GNU GPL v3.0   Bashblog was created out of the necessity of a very, very simple way to post entries to a blog by using a public folder [on my server], without any special requirements and dependencies. Works on GNU/Linux, OSX and BSD. How simple? Just type ‘./bb.sh post’ and start writing your blogpost. Features:

  • Ultra simple usage: Just type a post with your favorite editor and the script does the rest. No templating.
  • No installation required. Download bb.sh and start blogging.
  • Zero dependencies. It runs just on base utils (date, basename, grep, sed, head, etc)
  • GNU/Linux, BSD and OSX compatible out of the box, no need for GNU coreutils on a Mac. It does some magic to autodetect which command switches it needs to run depending on your system.
  • All content is static. You only need shell access to a machine with a public web folder. Tip: advanced users could mount a remote public folder via ftpfs and run this script locally
  • Allows drafts, includes a simple but clean stylesheet, generates the RSS file automatically.
  • Support for tags/categories
  • Support for Markdown, Disqus, Twitter, Feedburner, Google Analytics.
  • The project is still maintained as of 2016. Bugs are fixed, and new features are considered (see “Contributing”)
  • Everything stored in a single ~1k lines bash script, how cool is that?! 😉


https://github.com/hmngwy/jenny https://github.com/hmngwy/jenny (31) Languages:Bash Templates:Bash License:MIT   Goal Jenny aims to provide the simplest way to blog with the smallest footprint possible. There are draft and forward (scheduled) posting support. Markdown through a modified Markdown.awk or MultiMarkdown.pl Pagination is fixed, i.e. your first post will always be in “Page 1”. Settings can be peristed in an rc file or overridden on run time through command arguments. The default theme is small and light, and the template nimble.


http://skf.jeannedhack.org/ https://github.com/moebiuseye/skf (19) Languages:Bash Templates:Custom License:GNU GPL v3.0   Goal StatiKiss Framework concentrates on performance and simplicity. Plugins can be created very easily. The three themes (Default, Redish and Split) are responsive and try to be as small as possible.


https://github.com/thalios1973/blog.sh https://github.com/thalios1973/blog.sh (9) Languages:Bash Templates:Custom License:MIT   blog.sh is a relatively simple static blog generation tool written in bash. It supports markdown (via pandoc, but other converters could be used) and a very basic templating system. It is designed for simplicity and easy of hacking.   Features

  • Create new
  • Save to draft
  • Edit existing or draft
  • Complete rebuild of site (good for updating template)
  • Basic templating
  • RSS 2.0
  • Planned (aka things I haven’t found time for)
  • Default .config file
  • Default basic template (one doesn’t exist)
  • Static page support
  • Document classes and ids available for CSS
  • Delete post
  • blog.sh was heavily inspired by Carlos Fenollosa’s bashblog.




https://blogc.rgm.io/ https://github.com/blogc/blogc (112) Languages:C Templates:Custom License:BSD 3-Clause   blogc is a blog compiler. It converts source files and templates into blog/website resources. It is designed to be used with make or any other similar build tool. It is also stateless and idempotent, no state is shared between blogc binary calls.


http://kristaps.bsd.lv/sblg https://github.com/kristapsdz/sblg (53) Languages:C Templates:None License:ISC   sblg is a blog tool for UNIX users. It uses libexpat to merge content and templates, both usually in HTML, into formatted HTML articles or Atom feeds. There are no other dependencies. sblg is built to be driven by a Makefile just like any other development tool: articles are like sources compiled into standalone pages, then linked into blog pages. See sblg(1) for details.


https://embedthis.com/expansive https://github.com/embedthis/expansive (6) Languages:C, Ejscript Templates:Ejscript License:GNU GPL v2.0, Commercial   Expansive is a powerful web site generator that quickly creates compelling web sites with dynamic content. It uses powerful templating, scripting and tooling to provide a complete web site creation environment to accelerate your web application development



http://ctrl-c.club/~philips/90s/ https://github.com/felipetavares/bake (24) Languages:C++ Templates:HTML License:WTFPL   Bake is a tool for generating blogs as if you were using make. Create a template, a bakefile and your markdown posts and you are ready to bake!   Philosophy To be as simple as:

  • vim post.markdown
  • Bake

nifty-site-manager (nsm)

https://nifty-site-manager.com nifty-site-man() https://github.com/nifty-site-manager/nsm (5) Languages:C++ Templates:Custom License:MIT   Nifty-site-manager is a cross-platform git-like and LaTeX-like site manager. You should be able to create any site you want (both static and non-static/dynamic) using nsm, though will need some kind of web server such as Apache, NGinx, a LAMP stack, etc. to host non-static/dynamic sites, whereas static sites can easily be hosted with platforms like BitBucket, GitHub, GitLab and Netlify.   Philosophy The intent for creating nifty-site-manager (aka nsm) in the first place was to make a command-line site manager that was as git-like and LaTeX-like as possible, the creator/developer of nsm has achieved just what was desired and hopes others may find it just as useful for their own wants and/or needs.



http://cryogenweb.org/ https://github.com/cryogen-project/cryogen (765) Languages:Clojure Templates:Selmer License:EPL 1.0   Cryogen is a simple static site generator built with Clojure. It’s shipped on Leiningen so setup is fuss free and there’s no need to mess with databases or other CMS systems. Cryogen reads through a directory containing your Markdown content, compiles it into HTML and injects the content into your templates with the Selmer templating system. It then spits out a ready-to-publish website complete with a sitemap and RSS feed.   Features

  • Blog posts and pages with Markdown
  • Tags
  • Table of contents generation
  • Default Twitter Bootstrap theme
  • Plain HTML page templates
  • Code syntax highlighting
  • Disqus support
  • GitHub Gist integration
  • Sitemap
  • Sass/SCSS compilation
  • RSS


https://perun.io/ https://github.com/hashobject/perun (311) Languages:Clojure Templates:Hiccup License:EPL 1.0   Simple, composable static site generator inspired by Boot task model and Metalsmith. Perun is a collection of Boot tasks/plugins that you can chain together and build something custom that suits your needs.


Plugins system

Everything in Perun is build like independent task. The simplest blog engine will look like:

  "Build blog."


  (comp (markdown)

        (render :renderer renderer)))


But if you want to make permalinks, generate sitemap and rss feed, hide unfinished posts, add time to read to each post then you will do:

(deftask build
  "Build blog."
  (comp (markdown)
        (render :renderer renderer)
        (sitemap :filename "sitemap.xml")
        (rss :title "Hashobject" :description "Hashobject blog" :link "http://blog.hashobject.com")
        (atom-feed :title "Hashobject" :subtitle "Hashobject blog" :link "http://blog.hashobject.com")

3d-party plugins

There are plenty of Boot plugins that can be useful in the when you are using perun:

  • boot-http – serve generated site locally using web server
  • boot-gzip – gzip files
  • boot-s3 – sync generated site to the Amazon S3
  • boot-less – task to compile Less to CSS
  • boot-sassc – task to compile Sass to CSS
  • boot-garden – task to compile Garden stylesheets to CSS
  • boot-autoprefixer – add vendor prefixes to your CSS
  • boot-reload – live-reload of browser css, images, etc.




http://wintersmith.io/ https://github.com/jnordberg/wintersmith (3479)





Wintersmith is a simple yet flexible static site generator. It takes contents (markdown, less, scripts, etc), transforms them using plugins and outputs a static website (html, css, images, etc) that you can host anywhere.

It ships with plugins for markdown and jade templates, if you need something else check the plugin listing or write your own



Wintersmith is written by Johan Nordberg using CoffeeScript and licensed under the MIT-license.   The name is a nod to blacksmith which inspired this project.


http://docpad.org/ https://github.com/docpad/docpad (2992) Languages:CoffeeScript

Templates:Eco, Any JS



Hi! I’m DocPad, I streamline the web development process and help close the gap between experts and beginners. I’ve been used in production by big and small companies for over a year and a half now to create plenty of amazing and powerful web sites and applications quicker than ever before.

What makes me different is instead of being a box to cram yourself into and hold you back, I’m a freeway to what you want to accomplish, just getting out of your way and allowing you to create stuff quicker than ever before without limits. Leave the redundant stuff up to me, so you can focus on the awesome stuff.



  • Out of the box
  • Completely file based meaning there is no pesky databases that need to be installed, and for version control you get to use systems like Git and SVN which you’re already use to (You can still hook in remote data sources if you want, DocPad doesn’t impose any limits on you, ever)
  • Choose from plenty of community maintained pre-made websites to use for your next project instead of starting from scratch everytime
  • Write your documents in any language, markup, templating engine, or pre-processor you wish (we’re truly agnostic thanks to your plugin system). You can even mix and match them when needed by combining their extensions in a rails like fashion (e.g. coffee-with-some-eco.js.coffee.eco)
  • Changes to your website are automatically recompiled through our built in watch system
  • Add meta data to the top of your files to be used by templating engines to display non-standard information such as titles and descriptions for your documents
  • Display custom listings of content with our powerful Query Engine available to your templating engines
  • Abstract out generic headers and footers into layouts using our nested layout system
  • For simple static websites easily deploy your generated website to any web server like apache or github pages. For dynamic projects deploy them to servers like heroku or nodejitsu to take advantage of custom routing with express.js. Deploy guide here
  • Built-in server to save you from having to startup your own, for dynamic deployments this even supports things like clean urls, custom routes and server-side logic
  • Robust architecture and powerful plugin system means that you are never boxed in unlike traditional CMS systems, instead you can always extend DocPad to do whatever you need it to do, and you can even write to bundle common custom functionality and distribute them through the amazing node package manager npm
  • Built in support for dynamic documents (e.g. search pages, signup forms, etc.), so you can code pages that change on each request by just adding dynamic: true to your document’s meta data (exposes the express.js req and res objects to your templating engine)
  • You can use it standalone, or even easily include it within your existing systems with our API

With amazing community maintained plugins

  • Use the Live Reload plugin to automatically refresh your web browser whenever a change is made, this is amazing
  • Pull in remote RSS/Atom/JSON feeds into your templating engines allowing you to display your latest twitter updates or github projects easily and effortlessly using the Feedr Plugin
  • Support for every templating engine and pre-processor under the sun, including but not limited to CoffeeScript, CoffeeKup, ECO, HAML, Handlebars, Jade, Less, Markdown, PHP, Ruby, SASS and Stylus – the full listing is here
  • Use the Partials Plugin to abstract common pieces of code into their own individual file that can be included as much as you want
  • Syntax highlight code blocks automatically with either our Highlight.js Plugin or Pygments Plugin
  • Get SEO friendly clean URLs with our Clean URLs Plugin (dynamic deployments only)
  • Lint your code automatically with our Lint Plugins: jshint and coffeelint
  • Concatenate and minify your JavaScript and CSS assets making page loads faster for your users with our Minify Plugins: htmlmin and grunt
  • Install common javascript libraries like jQuery, Backbone and Underscore directly from the command line – under construction, coming soon
  • Automatically translate your entire website into other languages with our Translation Plugin – under construction, coming soon
  • Add a admin interface to your website allowing you to edit, save and preview your changes on live websites then push them back to your source repository with the Admin Plugins
  • Pretty much if DocPad doesn’t already do something, it is trivial to write a plugin to do it, seriously DocPad can accomplish anything, it never holds you back, there are no limits, it’s like super powered guardian angel
  • There are also plenty of other plugins not listed here that are still definitely worth checking out! 🙂


http://roots.netlify.com https://github.com/jescalan/roots (1477) Languages:CoffeeScript




Roots is a toolkit built on best practices for advanced front-end web development. It has a very large number of features, which I’ll attempt to list below. Roots comes in the form of a static site build tool by default, but also includes templates and plugins for express and rails.

  • extremely simple installation
  • clean and minimal default project template
  • clean and intuitive app settings file
  • jade, stylus, and coffeescript default stack
  • easy to add languages with a simple and well-documented plugin interface
  • super fast live reload implementation
  • compile errors displayed as a flash message, doesn’t break workflow
  • layouts and partials fully supported
  • coffeescript and markdown can be written directly in views
  • global variables and functions (view helpers)
  • extremely robust, modular, and powerful css helper library built in
  • single command deploy to heroku, nodejitsu, or github pages
  • intelligently minifies html, css, and js on deploy
  • efficient client-side js management through bower and require.js
  • automatically precompiles jade templates for use in client-side MVCs like backbone
  • use dynamic content to create collections, blogs, etc
  • compile a single file for multiple languages


https://github.com/fortes/enfield https://github.com/fortes/enfield (87) Languages:CoffeeScript Templates:Liquid License:MIT   Jekyll-like static site generator for node.js that aims to be as compatible as possible with Jekyll.   Features   Core functionality is identical to Jekyll:

  • Blog aware static site generator
  • Compatible with the Jekyll directory and file structure
  • Use Markdown for posts
  • Code highlighting via Pygments or Highlight.js
  • Layouts written using Liquid template engine
  • Server / Auto-regenerate
  • Extension-less page URLs (i.e. /example/ from /example.html via pretty_urls configuration variable)

There are a few bonus features not present in the default install of Jekyll:

  • Jekyll-like plugin model, with CoffeeScript/JS instead of Ruby
  • Use Markdown within includes
  • Compile and minify CoffeeScript & LESS
  • Support post and page URL aliases via redirects

Finally, there are a few missing features:

  • Textile support
  • Importing tools


https://github.com/AlynxZhou/hikaru/ https://github.com/AlynxZhou/hikaru (13) Languages:CoffeeScript Templates:Nunjucks


A static site generator that generates routes based on directories naturally, powered by Node.js, NPM and CoffeeScript.

You can control how pages are placed with Hikaru, you put a file in srcs, it will show the same path in docs.





https://github.com/kambrium/dssg (11)





DSSG is a static site generator written in the D programming language. It creates HTML pages out of Markdown files and Mustache templates.





https://github.com/embedthis/expansive (6)

Languages:C, Ejscript


License:GNU GPL v2.0, Commercial

Expansive is a powerful web site generator that quickly creates compelling web sites with dynamic content. It uses powerful templating, scripting and tooling to provide a complete web site creation environment to accelerate your web application development.





https://github.com/BennyHallett/obelisk (326)


Templates:EEx, Haml



Obelisk is a static site generator written in Elixir Programming Language.


Fast. Static websites can take a long time to generate when they start to grow large. obelisk should take advantage of Elixir’s processes to increase this speed.

Simple, Obvious. It should be very straight forward to add new content and modify the way that your site works.

Templatable. It should be possible to store templates in github repos and reference them directly, allowing modification of the look and feel of a site instantaneously with no manual installation.



https://github.com/Dalgona/Serum (118)





Serum is yet another static website generator written in Elixir Programming Language. The goal of this project is to provide the way to create awesome static websites with little effort. Powered by super-lightweight Erlang processes, Serum can build hundreds of pages simultaneously, enabling fast live tests (using Serum development server) and fast deployment of your website.

Check the sample website to see what Serum can do! The official website of Serum is under construction and will take position of the sample site.








Glayu is a static site generator focused on mid-sized sites that generate daily content like magazines and newspapers.

What makes Glayu different from other static site generators is the way it structures the source folder: when you publish an article using Glayu, the markdown file is placed inside a subfolder of the source directory following the permalink definition. Glayu takes advance of this folder organization to enable the concurrent and partial generation of the site.



  • Partial site generation.
  • Well organized source folder.
  • Fast, thanks to Elixir and the Erlang VM.








Coil is a minimalistic static content engine written in Elixir Programming Language.




https://korban.net/elm/elmstatic/alexkorban(546) https://github.com/alexkorban/elmstatic (99)



License:GPL 3.0


Elmstatic is a static site generator that allows you to write page layouts in Elm, and content in Markdown. You’re free to use whatever you like for layouts: elm/html, elm-css, elm-ui etc.

It can generate sites with pages and blog posts, post tags and post lists for each tag, subsections with their own post streams, and RSS feeds.



Lambda Pad


https://github.com/gar1t/lambdapad (109)



License:Apache 2.0


Lambda Pad can be used to generate a static site. Here’s the gist:

Maintain data in various formats

Maintain templates and related static content

Use an Erlang module to generate a static site


Why Another Tool?

It’s fair to say that static site generation is a solved problem. Why would anyone want to created yet another static site generator when there are so many well established, robust, proven tools already?

Because the world needs a static site generator that embraces functional thinking. What does that mean?

Behavior should be obvious, or as obvious as possible without excessive verbosity

Users should not be stupefied and confused by implicit or otherwise magical behavior

Solutions should be small and focused to make them easier to understand — in general, the principle of separation of concerns should be evident when using the tool

When the goodness of functional thinking is applied to static site generation, users will have more fun and be more productive!


Why Erlang?

Erlang is a simple, easy-to-learn functional language that’s incredibly powerful. It’s known for building highly reliable, massively scalable systems (shout-out to WhatsApp — hey, what do you guys think of sponsoring a six week Lambda Pad sprint in Fiji?) but it’s also terrific for tasks like site generation. Erlang term syntax is low-noise and expressive. Erlang functions are beautiful and maintainable.

Erlang is also pretty dang fast!

The question is not so much Why Erlang, but Why Not Erlang?

Most static site generators use so called “human friendly” languages for configuration and customization. A few of the more popular options include YAML, JSON, Ruby, and Python. Lambda Pad will show that Erlang — yes, straight up Erlang — should be counted among the usual suspects for ease-of-use, clarity, and productivity!




https://gohugo.io/GoHugoIO(7338) https://github.com/gohugoio/hugo (36867)



License:Apache 2.0


Hugo is a static site generator written in Go. It is optimized for speed, easy use and configurability. Hugo takes a directory with content and templates and renders them into a full html website.

Hugo makes use of Markdown files with front matter for meta data.

A typical website of moderate size can be rendered in a fraction of a second. A good rule of thumb is that Hugo takes around 1 millisecond for each piece of content.

It is written to work well with any kind of website including blogs, tumbles and docs.





Templates:Markdown, Go



An elegant static blog generator, powered by Golang.


Easy Use

  • Simple & Cross Platform


Fast Build

  • 1000+ Posts Per Second


Elegant Theme

  • Fresh Visual Style



https://github.com/wendal/gor (583)



License:BSD 3-Clause


Transform your plain text into static websites and blogs. Gor is a Ruhoh-like websites and blog generator engine written in Go. It’s almost compatible to ruhoh 1.x specification. You can treat Gor as a replacement of the official implementation that is written in Ruby.

Why reinvent the wheel? Gor has the following awesome benefits:

  1. Speed—Less than 1 second when compiling all my near 200 blogs on wendal.net
  2. Simple—Only one single executable file generated after compiling, no other dependency



https://github.com/piranha/gostatic (350)





Gostatic is a static site generator. What differs it from most of other tools is that it’s written in Go and tracks changes, which means it should work reasonably fast.


Features include:

  • No run-time dependencies, just a single binary – download it and run
  • Dependency tracking and re-rendering only changed pages
  • Markdown support
  • Flexible filter system
  • Simple config syntax
  • HTTP server and watcher (instant rendering on changes)


Quick Start

Run gostatic -i my-site to generate basic site in directory name. It will have a basic config file, which you should edit to put relevant variables at the top – it also contains description of how files in your src directory are treated.

src directory obviously contains sources of your site (name of this directory can be changed in config). You can follow general idea of this directory to create new blog posts or new pages. All files, which are not mentioned in config, are just copied over. Run gostatic -fv config to see how your src is processed.

site.html is a file that defines templates your are able to use for your pages. You can see those templates mentioned in config.

And, finally, there is a Makefile, just for convenience. Run make to build your site once or make w to run watcher and server, to see your site changes in real time.

Also, you could look at my site for an example of advanced usage.

Good luck! And remember, your contributions either to gostatic or to documentation (even if it’s just this README.md) are always very welcome!



https://github.com/mkaz/hastie (153)





Hastie is a static site generator, written in Golang, relatively compatible with jekyll format. Use markdown for posts, supports RSS and simple Go templates.


Why the name “Hastie”?

The name Hastie is from a character in the novel Dr. Jekyll and Mr. Hyde.






License:AGPL v3.0


Most. Zen. Static. Website. Generator. Ever.

Why another one? C’mon, you must be kidding…

I just wanted to set up a very simple website (just a few pages) with Jekyll and it didn’t feel right. I didn’t want a blog.

I checked other projects but they were incomplete, cumbersome or solved the wrong problem (blogs, blogs everywhere). I wanted a zen-like experience. Just a layout and some Markdown files as pages with unobstrusive structure and configuration.


Yes, it is another NIH but… I think Zas is a different kind of beast. I admit that I probably overlooked some projects.


Where is the difference?

Gophers. Yes, there is Hugo (kudos!) but… Who wants to learn another directory layout? There is also Hastie too. If you want a blog.

Markdown only. And HTML, if you want.

Just a loop. Zas just loops over all .md and .html files in current directory (and subdirectories), ignoring all any other file (including dot-files).

Your imagination as limit. Zas has a simple extension mechanism based in subcommands. Do you really need to handle a blog with Zas? Install/create a new extension and do it!

Unobstrutive structure, no ‘_’ files. More in Usage section.




$ go get github.com/imdario/zas

Go to your site’s directory and do:

$ zas init

A .zas directory will be created with sane defaults. Put your layout in .zas/layout.html and you are ready.

$ zas

Yes. Enough. Your delightful site is on .zas/deploy. Enjoy.

What is happening here? Well, “generate” subcommand is called by default. This subcommand accepts the following flags:

-verbose: print ALL the things!

-full: generates all the input files. By default, zas has an incremental mode which keeps source and deploy directories in sync.








Simple-website is a static site generator written in Go. It takes Markdown as input, and gives you a static, simple, and responsive website as output. Posts and pages are supported.

Simple-website has been designed with technical simplicity and readability in mind – there are no configuration options and no themes to choose from. The workflow is simple – initialize a website using simple-website, create and/or edit Markdown files, run simple-website again – and publish.


Get it

go get github.com/alexanderte/simple-website

Initialize website

mkdir title-of-website

cd title-of-website



Create content

$EDITOR _sections/header.md

$EDITOR _posts/YYYY-MM-DD-title-of-post.md

$EDITOR _pages/title-of-page.md



MIT License

Copyright © 2018 Alexander Teinum

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.









Polo is a static blog rendering tool created with Golang.

I’m happily using it on my blog: http://agonzalezro.github.io, which means that works fine 🙂

Yes, I know that there a lot of them out there but I just want mine to learn a little bit of Go coding.

Key features

  • Markdown support with Metadata parsing compatible with Jekyll, Pelican & others
  • Embedded daemon with autoregeneration of the htmls in case of any change on the input files.
  • Archive, tags, RSS & pages support
  • Disqus comments
  • Google Analytics support with just a change on the settings
  • Share this support as well
  • Cool & easy way to re-template it, check the documentation or my blog post about it Quick!



Download your version from Gobuild

Get a JSON config from here

Run polo -config [path_to_your_conf] [your_folder_with_mds] [your_output_path]

If the config is called config.json and it’s on your current directory, you don’t even need to specify it.


One more thing

You can run polo with the -daemon option which will start a server serving your generated content and in case that you change any of the files in the input folder it’s going to autoregenerate the site.



https://github.com/mirovarga/litepub (28)





LitePub is a static blog generator that tries to be as easy to use as possible.

It requires no software dependencies, needs no configuration files, uses no databases. All it needs is one binary, posts written in Markdown and a set of templates to render the posts to static HTML files.

Posts don’t have to include any special metadata (aka front matter) like title or date in them – the title, date and optional tags are parsed from the natural flow of the posts.








Magnanimous is a simple, fast static website generator made for programmers.

It has its own tiny template language to make it as easy as possible to include files or part of files into other files, re-use variables, use for loops over literals or collections (e.g. files in a directory), compose components and many other things.

It is written in Go, so it is distributed as a single binary in all platforms, runs extremely fast and integrates very well with other Unixy tools.




http://sysgears.com/grain https://github.com/sysgears/grain (146)



License:Apache 2.0


Grain is a wide-purpose static website generator for Groovy / Gradle.


  • Live preview to make and see changes on the fly
  • Embedded Groovy code processing for content files and templates
  • Resource URL mapping to dynamically create pages or rewrite URLs
  • Template nesting and tag libraries for DRY code



  • Markdown, reStructuredText and AsciiDoc
  • Python Pygments code highlighting
  • SASS / SCSS stylesheets
  • Source compression and minification
  • Comes with
  • Bootstrap themes and examples for easy start
  • Gradle plugin for integration with existing projects