What does HackerNews think of zola?

A fast static site generator in a single binary with everything built-in. https://www.getzola.org

Language: Rust

#2 in Markdown
#20 in Rust
#1 in Jekyll
I use Zola (https://github.com/getzola/zola) to generate static site from Markdown and host it via GitHub Pages.
i’m using Zola static site generator for my website (after switching from Wordpress)

https://github.com/getzola/zola

https://mishushakov.gumroad.com/l/mish-zola

if you need more than that for a static blog (like Gatsby/NextJS) i’d consider you unreasonable

https://learnbyexample.github.io/

I'm using Zola SSG (https://github.com/getzola/zola) and hosted on GitHub Pages. I write about Regular Expressions, CLI one-liners, Scripting Languages, Vim, self-publishing, etc.

I write my books in markdown and convert to pdf/epub/web using pandoc and mdbook. I find markdown easier to work with and I don't know much about web development. So, I use Zola (https://github.com/getzola/zola) for my blog (https://learnbyexample.github.io/). It is a static site generator, clone a theme you like and start writing posts in markdown.
No you're absolutely right -- these are all headless CMSes, I did not actually complete the JAMstack, only the wrong piece -- I don't know what I was thinking, don't know what made me zoom in on CMSes so much, guess I think of them as more important than the front-end in a JAMstack.

As recompense, some lesser known options for the frontend part of the JAMstack that weren't mentioned in the original post:

- https://github.com/getzola/zola

- https://hexo.io/

- https://www.getblades.org/getting_started.html

>And I like Hugo because of that “it’s just a binary” bit. There’s no dependency hell.

I had that issue with Jekyll, I just couldn't get the set up to work on my system (to be fair, I gave up easily instead of asking for help).

When I came across Zola (https://github.com/getzola/zola), I was immediately drawn by the single binary aspect.

Earlier this year, I made a site using Zola. I was quite happy with it once I got past some of the quirks when dealing with URLs.

https://github.com/getzola/zola

I've made a few things:

- Zola (https://github.com/getzola/zola) a SSG that works like I wanted and had a template engine close to Jinja2. I was using Hugo at the time but can't stand Golang template engine (imagine my sadness recently when I realised what Helm Charts are using...)

- Tera (https://github.com/keats/tera): a template engine pretty close to Jinja2/Django templates - at the time it was made only Handlebars existed in Rust and it was not enough for what I needed in Zola

- kickstart (https://github.com/Keats/kickstart): an equivalent of cookiecutter from Python but trying to be more interactive/powerful as a simple binary, see the GIF in the repo for an example

- validator (https://github.com/Keats/validator): my take on Python marshmallow validations, nothing existed at the time.

So yeah, most of my open-source is re-creating libraries I use with Python in Rust.

I used Hugo some years ago[1] and my memory of it was mostly negative in terms of usability. I revisited it again this year for another project and it drove me so mad that I ended up switching to Zola[2].

My issue with Hugo was that it just wasn't reliable with what was in the cache so I could never trust whether what I saw was actually the state of the site and causing me to push a broken state to the remote server. Hugo is great if it works but I found it a nightmare to deal with when it doesn't.

There are countless options in Hugo (yes I understand it's powerful but I rather it just had half the option and they work as advertised), some of which at times are contradictory so searching for solutions took me ages. I have no affiliation with the zola project and am not even big on Rust. Zola just worked for me and seems a lot less "hacky" than hugo thanks to the Tera templating system.

The Author of Zola writes on his github:

> [hugo] personally drives me insane, to the point of writing my own template engine and static site generator.

a sentiment that I share very much.

[1] https://web.archive.org/web/20180714043311/https://iotdarwin...

[2] https://github.com/getzola/zola

[3] https://github.com/getzola/after-dark

For those who want to like Hugo, but can't stand the templating language: there's also Zola (https://github.com/getzola/zola), a superb static site generator, with built-in Sass compilation, written in Rust.
Zola [0] has a comparison table between Zola, Cobalt, Hugo and Pelican. I tried out Zola because I saw somewhere that it was single binary (had heard of Hugo, but didn't know it was single binary). I moved my blog from Jekyll to Zola as I found a theme I liked.

[0] https://github.com/getzola/zola

I'm currently using a Jekyll based theme to host my blog via GitHub pages. I'll most likely switch to static-site generator using zola [0]. I don't much know about web development, but fine with markdown based site generation. Was struggling with zola docs, until I found that I can simply clone themes [1] and replace the sample posts. I'll go through settings later. Best thing I like about zola is that I get a single binary (this is based on rust) and I don't have to fiddle with npm, etc.

[0] https://github.com/getzola/zola

[1] https://www.getzola.org/themes/

1. Mostly self-promotional articles to lead towards my ebooks. But I'm proud of my 'customizing pandoc' and 'what next in Python' posts.

2. I am averaging about 1 post per 2 months :(

3. GitHub, because it is free and I can use markdown. Currently using a jekyll theme, but I'm planning to switch to static-site generator like https://github.com/getzola/zola

4. https://learnbyexample.github.io/

Since you mentioned Rust and since this is turning into a "suggest a static site generator" thread, I'll mention Zola: https://github.com/getzola/zola , although I can't say how well it works for photo galleries.
Just think of the immense amount of work a compiler is doing to compile a decently sized C++ or Rust binary.

If there was a need for it, static site generators could be scaled to tens or hundreds of thousands of pages and still finish in a few seconds. Caching partial results is always an option.

There are generators that are decently performant, like Hugo (Go) [1] or Zola (Rust) [2].

[1] https://gohugo.io/ [2] https://github.com/getzola/zola

And for people who want "Hugo but written in Rust" or "Hugo but written in Javascript" — then, there's Zola (Rust): https://github.com/getzola/zola, and 11ty (Javascript): https://github.com/11ty/eleventy. (Or at least that's how I think about these two.)
I switched my personal Jekyll site to Gatsby 2 years ago. I ran into some minor bugs and even contributed 3 PRs that got merged. I loved working with it for a few weeks. Two months after switching, it too dawned on me how over-engineered it is. I switched off of it to a custom static site generator I made (admittedly it was also over-engineered), but I'm finally back to a simple static generator called zola [1] and it feels so refreshing.

Not only is Gatsby over-engineered, it's also bloated IMO. I think one of their main selling points it that page loads seem instant. Preloading other pages in the background seems needless to me when we're talking about a simple blog. Sure, it might be good for apps, but forcing my (few) visitors to download needless mbs on desktop or mobile seems like a bad user experience to me.

[1]: https://github.com/getzola/zola

There's Zola, a bit like Hugo but written in Rust,

https://github.com/getzola/zola,

and, looking at the readme, a bit more features than Hugo, e.g. built in search (how does that work?).

I used Zola [0] + Caddy [1] with the http.git plugin [2] and docker. I generate the assets with Zola, then rsync them to a separate repository and Caddy automatically pulls in the changes whenever I git push.

Source here: https://git.sr.ht/~andrewzah/personal-site/tree

[0]: https://github.com/getzola/zola [1]: https://github.com/caddyserver/caddy [2]: https://caddyserver.com/docs/http.git