Hugo: Fast Static Site Generator Written in Go

What Hugo is

Hugo is a static site generator written in Go, optimised for speed and designed for flexibility. It takes content written mostly in Markdown, combines it with templates, themes and assets, and renders a complete website as static files. The README says that with its templating system and fast asset pipelines Hugo renders a complete site in seconds, often less. It is licensed under Apache-2.0, and the README credits bep, spf13 and friends as its builders.

Because of its flexible framework, multilingual support and taxonomy system, the README lists a wide range of sites built with it: corporate, government, nonprofit, education, news, event and project sites; documentation sites; image portfolios; landing pages; business, professional and personal blogs; and résumés. The common thread is content that can be pre-rendered and served from any static host or CDN, with no application server or database at request time.

For developers the appeal is a single self-contained binary. Hugo's embedded web server shows changes to content, structure and presentation instantly during development, and the same binary produces the final build that you deploy to a host or let a Git provider build automatically.

How it works

A Hugo project is a directory skeleton created with hugo new project. Content lives in content/ as Markdown files with front matter; the quick start shows TOML front matter with title, date and draft fields. Configuration lives in hugo.toml at the project root, where you set baseURL, locale, title and the theme. Themes can be added as Git submodules or through Hugo Modules.

During development hugo server runs the embedded server and rebuilds on change. Draft content, marked with draft = true, is excluded from builds unless you pass --buildDrafts or -D. Running hugo on its own publishes the project: it renders every build artefact, including the HTML for every site and assets such as images, CSS and JavaScript, into the public directory. The docs distinguish publishing, which produces those files, from deploying them to a host.

Markdown rendering conforms to the CommonMark specification. Asset processing happens inside the same binary; the README's dependency list includes libraries such as esbuild and minify, and Hugo also bundles libwebp, KaTeX and QuickJS in binary or WASM form.

Key features

• CSS processing: bundle, transform, minify, create source maps, perform SRI hashing and integrate with PostCSS.
• Image processing: convert, resize, crop, rotate, adjust colours, apply filters, overlay text and images, and extract metadata.
• JavaScript bundling: transpile TypeScript and JSX, bundle, tree shake, minify, create source maps and SRI hashes.
• Sass processing: transpile Sass to CSS with the same bundling, minification, source map and PostCSS options; Dart Sass is the recommended transpiler.
• Tailwind CSS processing: compile Tailwind utility classes into standard CSS and optimise the output.
• Hugo Modules: share content, assets, data, translations, themes, templates and configuration between projects through public or private Git repositories.
• Multilingual sites and taxonomies: built-in support for multiple languages and for classifying content with taxonomies.
• Embedded development server: live preview of every change while you edit.
• Editions: the standard edition covers core features; the deploy edition adds direct deployment to a Google Cloud Storage bucket, an AWS S3 bucket or an Azure Storage container.

Getting started

Hugo installs from prebuilt binaries, package managers or package repositories, with instructions for macOS, Linux, Windows and the BSDs. On macOS or Linux, Homebrew installs the extended/deploy edition:

brew install hugo

To build the standard edition from source you need Git and Go 1.27.0 or later:

CGO_ENABLED=0 go install github.com/gohugoio/hugo@latest

or, for the deploy edition:

CGO_ENABLED=0 go install -tags withdeploy github.com/gohugoio/hugo@latest

The official quick start requires a recent Hugo release and Git. It checks the version, then creates a project with the Ananke theme and starts the development server:

hugo version

hugo new project quickstart
cd quickstart
git init
git submodule add https://github.com/gohugo-ananke/ananke themes/ananke
echo "theme = 'ananke'" >> hugo.toml
hugo server

Add a first post, which is created as a draft:

hugo new content content/posts/my-first-post.md

Preview it with drafts included:

hugo server -D

When the content is ready, set draft to false, adjust baseURL, locale and title in hugo.toml, and publish the site to public/ by running hugo. Windows users are told to run the commands from PowerShell or a POSIX shell such as Bash in WSL or Git Bash, not from Command Prompt or Windows PowerShell.

Use cases

• Documentation sites: versioned product or API docs written in Markdown, built in CI and served from a CDN.
• Engineering and personal blogs: write posts as Markdown files in a Git repository and deploy on every push.
• Marketing and landing pages: fast static pages with processed images, Tailwind CSS and minified bundles.
• Multilingual sites: one project serving several languages using Hugo's multilingual support.
• Portfolios and résumés: image-heavy sites that rely on the built-in image processing.
• Shared design systems: distribute themes, templates and configuration across many sites with Hugo Modules.
• Direct cloud publishing: use the deploy edition to push a build straight to S3, Google Cloud Storage or Azure Storage.

How it compares

The README does not name competing generators, so comparisons are general. Against static site generators that run on Node.js or Ruby, Hugo's main differences are that it ships as one Go binary, needs no language runtime for basic use, and does asset processing (Sass, TypeScript and JSX bundling, Tailwind, image processing) inside that binary; Git and Go are only needed for modules, themes as submodules or building from source. Against JavaScript meta-frameworks that can also pre-render pages, Hugo is template-driven rather than component-driven and has no client-side application runtime of its own. Against a hosted CMS, the trade-off is the usual static one: no server or database to maintain, but editing happens in files and Git rather than in a web admin, unless a separate CMS is layered on top.

Things to know before adopting

• Pre-1.0 versioning: releases are numbered 0.x (v0.169.0 at the time of writing) and ship frequently, so pin the Hugo version in CI and themes; the quick start itself declares a minimum version.
• Editions matter: Homebrew installs the extended/deploy edition, while a plain go install builds the standard edition; direct cloud deployment needs a deploy edition.
• LibSass is deprecated: embedded LibSass, available in the extended editions, was deprecated in v0.153.0 and will be removed; the docs recommend Dart Sass, which works with any edition.
• Prerequisites by feature: Git is required for Hugo Modules, Git-submodule themes and commit information; Go is required for modules and source builds.
• Support channel: questions belong on the forum, not the issue tracker, and feature work starts as a forum topic and an accepted proposal before any pull request.
• Bundled components: libwebp (BSD-3-Clause), KaTeX (MIT) and QuickJS ship inside the binary alongside the Apache-2.0 Hugo source.

Project activity

As of October 2026 the repository has about 90,300 stars and 8,400 forks. It was created in July 2013, is written in Go and is licensed under Apache-2.0. Releases land roughly every two weeks: v0.167.0 on September 28, v0.168.0 on October 13 and v0.169.0 on October 27, 2026. The documentation is maintained in a separate repository, and community support runs through a forum with over 20,000 topics. Source is at github.com/gohugoio/hugo and documentation at gohugo.io.