
Ask HN: What is setup for your static blog generator? - chauhankiran
I have tried Jekyll, Hexo and few other static blog generator but not happy with theme. I want to build something in which I have total control. Like I have few scss&#x2F;css files, few markup files and some other templates for design and based on them I can create a complete html files so that I can publish them on GitHub.<p>Many of you might have some scripts that generate your blog posts from some setup. If it is possible then can you share your setup configuration?<p>I am looking for following things with setup:<p>* I should have backup of my all posts if I want to move other other configuration.
* I can easily tweak css or html.
* I can generate a complete html blog that can be publish over GitHub or any other places.
======
nathan_f77
I use Hugo, GitLab, and Netlify for blogs and landing pages. I highly
recommend this combination. Hugo is blazingly fast and very customizable. It's
written in Go, so it compiles hundreds of blog posts in less than a second. My
old Jekyll and Octopress blogs used to take a few minutes.

Netlify is like Heroku for static sites. You can connect Netlify to GitLab
(free private repos), and Netlify will build and deploy your site when you git
push. I also use the Netlify nameservers for many of my domains, and it's
really easy to set up SSL with Let's Encrypt. I can buy a domain on Namecheap,
and have a new blog or landing page deployed in less than 5 minutes.

* [https://gohugo.io/](https://gohugo.io/)

* [https://gitlab.com/](https://gitlab.com/)

* [https://www.netlify.com/](https://www.netlify.com/)

~~~
seanwilson
How do you find the template syntax with Hugo? I love the speed of it over
Jekyll but I find the Hugo syntax really unintuitive sometimes. For example
why {{ if or (isset .Params "alt") (isset .Params "caption") }} and not {{ if
(isset .Params "alt") or (isset .Params "caption") }}?

~~~
joncalhoun
A lot of the syntax is a byproduct of the template packages shipped in Go.

I assume the ordering of or, if, etc is a byproduct of them being function
calls, but I'd have to double check to verify. Regardless it's a little weird
at first but you get used to it after a bit. I used a fair bit of
customization on the www.calhoun.io theme and I didn't have to think twice
about the order of terms after a short while.

~~~
dhruvkar
[https://gohugohq.com/howto/compare-date-strings-in-
hugo/](https://gohugohq.com/howto/compare-date-strings-in-hugo/)

This was a useful site for deeper exploration into the syntax. Sometimes, it's
just trial and error.

------
scrollaway
I use Jekyll for most of my blogs. For my company's, we needed multiple
authors including non-technical people, so we couldn't use git for that. I
recently discovered Ghost which I highly recommend:

* [https://ghost.org/](https://ghost.org/)

* Kickstarted in 2013

* Markdown-based

* Open source, self-hostable

* Hosted solution ([https://ghost.org/pricing/](https://ghost.org/pricing/)) with support for your own domain name

* Beautiful themes out of the box with custom css/js on an article, site-wide or theme level

* Third party static site generation tools ([https://github.com/axitkhurana/buster/](https://github.com/axitkhurana/buster/), [https://github.com/lexoyo/static-ghost](https://github.com/lexoyo/static-ghost))

Example blog (default theme):
[https://blog.ghost.org/](https://blog.ghost.org/)

~~~
bluehatbrit
I've been using Ghost for a few years now, mostly because it interested me and
looked nice to use. I've gone through a bunch of static blog generators and
while they were cool (and cheap) I just really like the ability to login to my
site, start drafting, have it auto-save and come back to it later. I'm not
super fussed about having it version controlled, though I can export all my
data (minus images) into a JSON format and version control that if I want.

I self host on the lowest Digital Ocean droplet which is now $5/mo and is
plenty for my small time blog and I'm happy to pay $5/mo for the delight of
using Ghost. Also with a cron job I can auto-update every few days and get the
latest features without touching the box.

Ghost will auto-roll back if an update fails which is nice and I don't have
that many viewers so if it goes down I don't mind so much right now.

A final bonus is that it uses handlebars for it's theme creation and
rendering. I'm a node dev who uses handlebars for my own projects so editing
my theme is a breeze.

------
gmueckl
I use Hugo ([https://gohugo.io](https://gohugo.io)) on my local machine to
create the website and upload the resulting static site to the server via
rsync. The website templates and CSS sheets are all custom, so I get total
control over the result.

~~~
lucaspiller
For anyone interested I created a privacy focussed theme for Hugo, with no
third party scripts or assets:

[https://github.com/lucaspiller/hugo-privacy-cactus-
theme](https://github.com/lucaspiller/hugo-privacy-cactus-theme)

I wanted a minimalist theme that's fast to load, but a lot of commonly cited
examples are too extreme or look too dated for my liking. I wanted the same
results, but something a bit more up to date and with code highlighting. You
can see the end result on my blog (total network transfer 78kB):

[http://www.stackednotion.com/blog/2016/07/09/setting-up-a-
ne...](http://www.stackednotion.com/blog/2016/07/09/setting-up-a-new-drive-on-
your-linux-nas/)

------
sago
A static site generator is just a build tool. You need some way to say what
your output files are, and what source files are needed to create them. This
is usually hardcoded (with some parameters and ad-hoc hooks) in something like
Jekyll, but could be specified with Make. I wrote a very simple timestamp
checker in a couple of dozen lines of Python.

Then your scss/less->css is probably best done with the command line compiler,
driven from your build tool.

And for HTML, take a template language you enjoy and write a simple driver
script. If you want multiple templates, add metadata to your source files. In
my case I want Markdown->HTML, using various templates, so I use YAML for the
metadata, then Python's markdown compiler, and finally Jinja2 for templating.
Again you can write the driver in a few dozen lines for your own purpose.

My build tools then calls The AWS API to send it to its S3 bucket, in most
cases. But in one it commits to a github pages branch and pushes.

It is exceptionally simple to code your own static site generator, if you can
do basic command line scripting. And doing it that way allows you to be very
flexible and add things like uploading, version control, etc.

I think it's better off seen as a command line tool, than a special 'static
blog generator' task. In general I think we are erring too far on the 'build a
niche vertical app' rather than 'automate powerful general-purpose tools'.

------
zeroping
Not a direct answer, but I just wanted to point out how handy it is that you
can publish to your public keybase directory, and have it hosted at
keybase.pub, something like this:

[https://abhi.keybase.pub/2016/02/15/git-and-
keybasefs.html](https://abhi.keybase.pub/2016/02/15/git-and-keybasefs.html)

The general gist is that keybase.io is promising that it will only serve data
at abhi.keybase.pub that has been signed for by that user.

~~~
dcreemer
This is brilliant information. Thanks for sharing it.

------
jakelazaroff
This will probably forever be too half-baked to "release", but I wrote my own:
[https://github.com/jakelazaroff/adjective](https://github.com/jakelazaroff/adjective)

It's written in Node and features multithreading and incremental builds for
fast development.

I host on Netlify, which has continuous integration built in, so it builds and
deploys the site every time I push to GitLab.

~~~
dcreemer
I'm also using Netlify (with Hugo). Their service is simple to use, and send
to work quite well.

------
stevenicr
I use wordpress.

add a plugin from the repo "simply static" \- generate the html files.

download, then ftp.

It's not elegant and lean like the others - but it's saved me a ton of time
for the use cases I've used it for.

There is another decent static generator in the repo, but it failed on a
recent site I was trying yesterday, so it's not on my currently using list.

I know it's possible to put wp dynamic files on a server and use a domain
mapping plugin to generate files for a bunch of domains on the same server
easily - could probably find someone smarter than me to add in this simply
static plugin and mod it to shoot the files to the sub domains...

then just install a bunch of themes and other plugins to the main install -
and might be kind of heavenly for a lot of situations.

Some of my wp sites need contact forms - so I'm leaving those live / dynamic.
If it was easier to make and upload something like the coffee cup form builder
files I'd convert a few more sites to static files this week.

If someone found a way to use the wordpress themes with these other generators
it would be awesome. Then it would just be the few sites that need the extra
plugins power that really need the wordpress php files and such. One can
dream.

------
viraptor
I don't know about others, but at least Jekyll has themes which you can modify
in whatever way you want. See a random theme at
[https://github.com/chrisbobbe/jekyll-theme-
prologue?files=1](https://github.com/chrisbobbe/jekyll-theme-prologue?files=1)

~~~
beisner
I use Jekyll, super easy and aesthetic

------
ethomson
Jekyll for my podcast's web site
([https://allthingsgit.com/](https://allthingsgit.com/)). I became a fan of
Jekyll when I worked at GitHub, but I don't use GitHub Pages, I needed to
scale it larger. (edit: in particular, I needed something that can host audio
and video.) So my workflow is GitHub for hosting, and Visual Studio Team
Services for CI builds. It monitors the GitHub repository and on commits to
master, it runs Jekyll in a docker container. It then deploys to Azure, where
I host the static web site. (I use Azure CDN for hosting the audio episodes.)

I would use VSTS for the whole pipeline, including the Git repository hosting,
but I wanted to have a public repository, in case listeners wanted to submit
pull requests. So far that hasn't happened, so I'm missing out on some of the
VSTS features, but maybe it still will.

I also have a weekly newsletter
([https://developertoolsweekly.com/](https://developertoolsweekly.com/)) that
uses a static site generator that I build myself. It's very Jekyll-inspired
and uses Liquid templates, but instead of generally processing markdown, it
takes a simple list of links and descriptions and emits a website as well as
the HTML and plain text for the emails.

This workflow is similar, the generator is run in a Docker container, but this
workflow is entirely VSTS and Azure.

------
rayalez
I'm very happy with using pelican for my blog:

[https://startuplab.io/blog](https://startuplab.io/blog)

It's very flexible, written in python, easy to customize, has plugins for any
purpose.

I've made a custom theme, configured pelican a bit, and served with nginx on
digital ocean(but it could as well have been served for free on github pages).

You can see the code and my custom theme here:

[https://github.com/raymestalez/startuplab](https://github.com/raymestalez/startuplab)

~~~
CogDisco
I moved to Pelican from WordPress last year and it's been great. I wish there
were more resources around for it, though.

------
gshrikant
Github pages + Bash + Python script. I have a very simple page layout for
posts. A drafts directory maintains ASCIIDoc files for posts I'm writing.

After writing I run `post.sh` with the file as the argument. It invokes a
Python script which generates the HTML and puts it in a directory for
published posts sorted by date/month/year (e.g. published/2018/01/29). The
Bash script generates a directory/link listing and an index page for the blog
roll, followed by a "git push".

------
1wheel
Jekyll was slow and hard to customize. A tiny script can convert a template +
a directory of markdown files to a blog pretty easily.

Less code and configuration makes it easy to add custom features; I stuck
incremental rebuilds and hot reloading into my blog while keeping it below 70
LOC:

[https://github.com/1wheel/roadtolarissa/blob/master/index.js](https://github.com/1wheel/roadtolarissa/blob/master/index.js)

------
rwieruch
I use Hugo [0] as a static website generator. They have plenty of themes [1]
to choose from. You can still adjust it with basic knowledge in HTML/CSS.
Afterward you can chose where to host it. You can use Github Pages [2] for
free or pay for a service like DigitalOcean (starting with 5€ a month which
scales well) [3]. I wrote a technical cheatsheet [4] on how to setup your own
website with these ingredients. You can find a more elaborate way on how to
host multiple static websites on Digital Ocean over here [5].

\- [0] [https://gohugo.io/](https://gohugo.io/)

\- [1] [http://themes.gohugo.io/](http://themes.gohugo.io/)

\- [2] [https://pages.github.com/](https://pages.github.com/)

\- [3] [https://www.digitalocean.com/](https://www.digitalocean.com/)

\- [4] [https://www.robinwieruch.de/own-website-in-five-
days/](https://www.robinwieruch.de/own-website-in-five-days/)

\- [5] [https://www.robinwieruch.de/deploy-applications-digital-
ocea...](https://www.robinwieruch.de/deploy-applications-digital-ocean/)

------
cperciva
I wrote my own for
[http://www.daemonology.net/blog/](http://www.daemonology.net/blog/) .
Basically it's a few template files, a /posts/ directory where I write the
content of blog posts (one per file), and a shell script which generates all
the html output.

Happy to share with anyone who wants it. Some day I'll get around to putting
it up on github.

------
deadcoder0904
I started with Jekyll which had tons of freely available themes (no link) then
went on to Hexo but it was slow (
[https://100dayz.js.org](https://100dayz.js.org) ) compared to my next one
Hugo (no link again) but Hugo was the fastest to generate since its made in
Go. Then I used different documentation generator like Docute (
[https://datastructures.js.org](https://datastructures.js.org) ) & Docsify,
etc...

Then now. Personal opinion but I love Gatsby (
[https://www.gatsbyjs.org](https://www.gatsbyjs.org) ). For me, it is the best
static site generator out there. Yes more than static site generator as it is
a PWA by default. It is infinitely scalable. It prefetches content before its
loaded (think about this as you get the data of Previous Blog Post & Next Blog
Post when you are on the Current Blog Post). Its so fast that you will
actually feel the speed. Also, with little efforts you can make it work
offline too.

------
TDettmering
We've built a whole UX toolkit (shameless plug:
[https://uxls.org](https://uxls.org)) with Hugo and Bootstrap on GitLab. It
was absolutely fantastic to work with this setup. Here's the source:
[https://gitlab.com/uxls/build](https://gitlab.com/uxls/build)

------
nfrmatk
I use Gutenberg ([https://www.getgutenberg.io/](https://www.getgutenberg.io/))
which provides built-in Sass compilation and live-reloading in a single
binary. I just write Markdown and generate posts with Tera
([https://github.com/Keats/tera](https://github.com/Keats/tera) ) templates
for my HTML, so if I ever wanted to migrate to something else it would be
trivial, but I'm a happy camper now.

When I'm ready to publish I just copy the public directory right to my
webserver, but I could just as easily publish to GitHub or the like if I
didn't enjoy maintaining my own domain.

------
Keats
I wrote my own as I wanted sass + syntax highlighting + a good template engine
without having to install Node or similar
([https://www.getgutenberg.io/](https://www.getgutenberg.io/)). Not a lot of
themes yet so it's better for peopl

In short, I just write my content in markdown, style in Sass and HTML in Tera
([https://github.com/Keats/tera/](https://github.com/Keats/tera/)) which is
very similar to Jinja2.

I then automatically build & deploy from
[https://www.netlify.com/](https://www.netlify.com/) on commits. Netlify will
also get built-in support the next time they deploy their build image (ie all
you need for your site to be deployed will be a file like
[https://github.com/Keats/gutenberg/blob/a2b55a927981727ce00a...](https://github.com/Keats/gutenberg/blob/a2b55a927981727ce00a200a01ce1bd8aceb1390/netlify.toml))
like Hugo does.

My own site is a bit difference as I have a DO instance for it but the script
is simply copying the public folder to the server and have Caddy serve it.

------
kettlecorn
I had similar problems to yours: I wanted total control but I also wanted it
to be quick and easy when I’m writing a new post or page.

So I made my own tool.

With this tool (which I dubbed ‘Wabi’) you put a bunch of files in a folder
and the files are processed and copied to a corresponding location in an
output folder.

Files with metadata at the top are processed specially and can be used as
templates or to write markdown files that are turned into pages.

Wabi helps you setup Git integration so that when you run the “publish”
command all local changes are immediately published to your website. I didn’t
want to mess around with git stuff most of the time so I implemented that
command so I could publish iteratively and quickly.

Wabi is sort of my answer to wanting control over how I build my website,
while also wanting a tool that does not get in the way of the creative parts
of making and running a website.

That said, it’s of no use to you because it’s completely undocumented and not
polished, but probably over the next few months I’ll fix it up as I use it to
create my own personal website. For those interested you can check out the
source (it’s written in Go):
[https://github.com/kettle11/wabi](https://github.com/kettle11/wabi)

------
Jeaye
I run [https://blog.jeaye.com/](https://blog.jeaye.com/) on Github Pages, but
I manually build with Jekyll locally, with a publish script, and then force
push the built site + assets to the gh-pages branch. This allows me to use all
sorts of Jekyll plugins which Github won't whitelist.

I'm currently writing a post detailing how all of this works, for anyone
interested.

~~~
city41

        git subtree push --prefix build origin gh-pages  
      

is a nice simple way to push your build directory to the gh-pages branch.

------
kqr
I have tried various solutions including Jekyll, some Haskell scripts, and a
home made POSIX shell tool built on make, m4, awk etc.

What has worked best so far is Org publishing. The reasons I prefer it are
primarily that

1\. The Org file format is olain text, easily edited on the phone and
generally great.

2\. I can embed source code in many different languages and have it execute
during publishing and embed its results in the document. This can be used both
for a "Python notebook" style document, and to programmatically generate
things like markup!

3\. I can write a single coherent document and then slice it different ways to
publish one technical manual as PDF, one summary blog post, and some slides
with key points -- all from the same source material.

4\. The publishing process is very hackable, so customizations are easy.

(Of course, you don't have to use Emacs as your editor, you can just create a
git hook or alias to run Org publish in shell script mode.)

------
tiefenb
We use [https://processwire.com](https://processwire.com) for our blog and
future more content sections. It's kind of a static generator which creates
JSON-Files with meta-information and the rendered HTML-maincontent. The static
processing is made with ProCache module and a python script which loads an
sitemap and requests all sites each 1-2 hours.

we choosed this setting because we wanted the content-heavy parts in an easy
to handle CMS (from a editor perspective). We wanted to integrate the content
in our main webshop and not with a subdomain and between our main header and
footer coming from our main webshop system (sap hybris).

show hn: [https://www.blue-tomato.com/blue-world/](https://www.blue-
tomato.com/blue-world/)

------
kccqzy
I use Hakyll, which is a Haskell clone of Jekyll. I wouldn’t recommend it
unless you are already proficient in Haskell and Haskell is your favorite
language, but it does give you total control: write a few markdown files, your
own HTML templates, your own CSS, etc.

------
djsumdog
I have Jekyll setup (not recommended, see below) to generate my sites in a
Docker container. The builder container outputs my websites into a volume
that's shared with nginx. I have shared assets for multiple websites and had
to create a custom plugin to support this setup in Jekyll:

[https://github.com/sumdog/jekyll-multisite](https://github.com/sumdog/jekyll-
multisite)

There are open issues and pull requests for the plugin. I started building a
test suite so I could start doing tests against multiple Jekyll versions and
make it more universal, but it currently fails tests even with the same
Gemfile/lockfiles.

Currently I have to keep my site pegged to Jekyll 3.0.1 because of all the
custom plugins I've written, and think Jekyll-multisite might be tied directly
to my build. :( I've put little effort into it lately since Jekyll themes are
suppose to address the multi-site capabilities. I just keep it building a a
docker container so I can use the older version without trouble.

I have that nginx container running behind the official HAProxy container and
have Certbot running in its official container as well. I have a guide on how
to set this up including all the Dockerfiles on github that you can use and
modify:

[http://penguindreams.org/blog/bee2-automating-haproxy-and-
le...](http://penguindreams.org/blog/bee2-automating-haproxy-and-letsencrypt-
with-docker/)

As you can see, my blog isn't on the new setup yet (no https/letsencrypt). I'm
working on that though, and hope to have it all migrated over this week.

I would __NOT __recommend Jekyll if I was starting again. I had to do a lot of
hacking and custom ruby coding to get really basic things I wanted working.
Under the shell of Jekyll is a huge mess. It likes to iterate over things .. a
lot .. all the time, for everything. Lots of the path resolution stuff is
broken and lots of Jekyll is built around github pages, making some things
impossible without violating the security model.

~~~
busterarm
I wouldn't recommend trying to fit a square peg into a round hole either.

------
ht_th
I am using pandocomatic¹ to generate my website. It uses pandoc² to convert
all kinds of input files to HTML output and pandocomatic is controlling that
conversion. Applying it to a directory it converts, copies, or skip everything
recursively given a flexible templating system. In the end, it gives me total
control over the output and I have started using it for all my websites.

¹ Manual:
[https://heerdebeer.org/Software/markdown/pandocomatic/](https://heerdebeer.org/Software/markdown/pandocomatic/)
² [https://pandoc.org/](https://pandoc.org/)

~~~
freosam
The thing I've never figured out with my Pandoc-generated static sites is how
to generate RSS feeds from Markdown frontmatter metadata.

~~~
ht_th
For these type of task, pandocomatic supports preprocessors, postprocessors,
filters, setup scripts, and cleanup scripts in its templates.

For your specific issue, and this is a general pandoc solution, filters with
side effects could work. For example, you can write a filter that would
extract and inspect the metadata and writes it to to an RSS XML file.

In Paru¹, the Ruby wrapper and interface to pandoc, a very naive solution
could look like:

    
    
        #!/usr/bin/env ruby
        require "paru/filter"
        require "rss"
    
        RSS_FILE = "my-rss-file.rss"
    
        title = "No title"
        date = Time.now.to_s
    
        # Collect metadata information while filtering a document with pandoc
        Paru::Filter.run do 
            title = metadata["title"] if metadata.has_key? "title"
            date = metadata["date"] if metadata.has_key? "date"
        end
    
        # Create new Atom item
        new = RSS::Maker.make("atom") do |maker|
            maker.channel.author = maker.channel.about = maker.channel.title = ""
            maker.channel.updated = Time.now.to_s
    
            maker.items.new_item do |item|
                item.title = title
                item.updated = date
                item.link = "Some link"
            end
        end
    
        # Add new item to existing Atom RSS feed
        rss = RSS::Parser.parse(File.read(RSS_FILE), false)
        rss.items.concat new.items
        File.write(RSS_FILE, rss)
    
    

(My apologies for the bad code, this is my first attempt at working with
RSS/Atom)

¹ [https://heerdebeer.org/Software/markdown/paru/#writing-
and-u...](https://heerdebeer.org/Software/markdown/paru/#writing-and-using-
pandoc-filters-with-paru)

------
ig0r0
Using Hugo ([https://gohugo.io/](https://gohugo.io/)) as static generator,
hosting everything on Github (take a look:
[https://github.com/igorkulman/coding-
journal](https://github.com/igorkulman/coding-journal)), deploying to Netlify
(free tier).

There are many good themes for Hugo
([https://themes.gohugo.io/](https://themes.gohugo.io/)), I use Beautiful
Hugo.

When writing a new post I: * create a new MD file with the post * commit +
push * Netlify takes care of the rest (fetch from Github, deploy)

------
busterarm
You mention trying Jekyll, etc, but not what doesn't work about them for you.

Jekyll really does give you full control. It also powers some pretty large
websites. Breitbart.com and Forthepeople.com (shameless plug) spring to mind.

------
anonytrary
Just write some markdown files in a flat directory, have a React-SSR app that
reads the files and passes the content as props to the app, through a
markdown-html component, then just render the it to a raw string. You can do
this in tens of lines of code. You can save your script and pass it any
markdown files as input, generating any blog you want. Add in a pics/ folder
that gets uploaded, and then just locally reference those in your html. I
would do this over Wordpress any day. Wordpress is too complicated for me.

------
BrandoElFollito
After having used Jekyll and Hugo I discovered Metalsmith.

Les of freedom, everything is a plugin. I am going to restart my blog with
this.

Plus Vue.js Plus Bulma for CSS (actually Bueify to make it work with Vue)

------
rapphil
I use pelican. It is quite similar to jekyll, but it is python based.
[https://blog.getpelican.com](https://blog.getpelican.com)

------
jamietanna
I build [https://jvt.me](https://jvt.me) with Jekyll, then perform some
optimisation like minification through Gulp.

I've got some custom Jekyll page generation through Jekyll plugins, so I can
list out my tags / categories into their own pages.

It's pushed to GitLab.com which runs CI to build the site in docker
containers, then deploys to my VPS, but could just as easily be sent to
Netlify or S3 or wherever, I just like having it on a VPS.

------
dxwc
I put together one a week or two ago, it runs pandoc on directories with
markdown files in them to generate html, and then generates an atom feed of
the md files if any content has been created/updated. html/css can be set in
pandoc template, atom feed information from yaml. It barely works but so far
it hasn't broken in my normal usages

[https://github.com/dxwc/post](https://github.com/dxwc/post)

------
davnn
Heavily customised Jekyll to get the following features working:

* Code snippets with syntax highlighting * Embed the results of computations like plots * Mathematical figures * Bibliographic citations * Footnotes

Wrote about it ([https://curious.observer/articles/a-modern-
blog/](https://curious.observer/articles/a-modern-blog/)), but didn't get to
"blogging" until now :)

------
nice_byte
I generate html from templates which are html interspersed with js. JS is used
to generate the dynamic parts. A simple js program prepopulates some data
structures and hands it over to the template. Once html files are generated I
put them up on S3. I write the posts in HTML because I've generally had bad
luck with getting markdown to get things to look exactly as i want them.

------
jozip
I wrote an absolutely tiny, no-frills, blog generator in Bash. It's self-
contained in that it contain everything it needs to run, including templates.
Whether or not this is a good idea, I can't say, but it works for me. You can
check it out at [https://github.com/jozip/pot](https://github.com/jozip/pot)

------
matclab
I use Nikola and host it on GAE. Works well.

* [https://getnikola.com/](https://getnikola.com/)

* [http://ontoblogie.clabaut.net/en/posts/201801/use-nikola-gae...](http://ontoblogie.clabaut.net/en/posts/201801/use-nikola-gae-on-android-device.html)

------
gunnihinn
I have a single asciidoc file, ~20 lines of CSS, and a Makefile that generates
a single HTML file with my blog and publishes a new post with:

$ make post

It works just fine.

------
mmczaplinski
I'm very surprised no one has mentioned GatsbyJS yet
[https://gatsbyjs.org](https://gatsbyjs.org).

You write your site in react, which is compiled into HTML at build time. After
the user fetches the HTML, gatsby prefetches all the resources that might be
needed later, so the site feels incredibly fast when navigating.

------
jimnotgym
> I want to build something in which I have total control

It is really trivial to build your own for a simple blog site. I like this
approach as the toolchain develops alongside the site!

Jinja2 templates, simple Python build script. That way you can write your
content in whatever format you like! To deploy just use a bash script. On
Github pages you can just git push of course.

------
meehow
There is a documentation how to host on github: [http://gohugo.io/hosting-and-
deployment/hosting-on-github/](http://gohugo.io/hosting-and-
deployment/hosting-on-github/)

I use hugo and deploy to cheap shared hosting with 3 lines long Makefile:

deploy:

hugo

rsync --progress --archive -zLcb ./public/ webhost:~/example.com/

------
feistypharit
Hugo plus forestry.io for anything that needs to be edited by non developers.
Publii for a quick and simple blog only.

~~~
sgallant
Happy to hear that! We (forestry.io) would love any feedback you might have.

~~~
pchal
hello -- forestry.io looks great, but I had a big problem with it -- there is
no support for MathJax within my markdown posts. I had math equations within
double-dollar signs and the forestry.io editor removed them, making my math-
based post render badly. Looks like there is no support for MathJax. I find it
hard to see why forestry.io should mess with the MathJax in my markdown file
-- why not leave it as raw text that I can edit?

------
Syncbo
I had th same problem , so I built one myself which is very easy to set up ,
configure and modify. Take a look , it's still early in development but works.
[Flake]([https://GitHub.com/padamsethia/flake](https://GitHub.com/padamsethia/flake))

------
derekperkins
We use [https://github.com/nozzle/react-
static](https://github.com/nozzle/react-static) with Netlify. If you're a
react user, this will feel just like Create React App, where other react
static site generators are much more opinionated.

------
john_mack
I rolled my own because I had _unreasonable_ expectations:

* Cost almost nothing even if massive traffic (I wish)

* Infinate scaling

* No markdown, just html

* Post from browser, no publishing utils

* No web server

* No database

* Important plugins - comments, social media, email list

* Templates (eventually)

Built with jquery, S3, Cloudfront

Finished but not tested, demo at
[https://jamackinnon.com](https://jamackinnon.com)

------
mahesh288
I am using Jekyll, Heroku and Git and here are instructions:
[http://www.reluctantwriter.in/dev/how-to-start-jekyll-
powere...](http://www.reluctantwriter.in/dev/how-to-start-jekyll-powered-
blog/)

Please let me know if you need help.

------
drakonka
I use Hugo for mine; I submit posts to a gitlab repo, then the CI deploys them
to Amazon S3. The setup is sort of clunky, specifically the upload step - it
usually fails and for some reason it insists on trying to re-upload unchanged
files, but I never get around to debugging it.

------
kentor
I wrote one for node: [https://github.com/kentor/tiny-
ssg](https://github.com/kentor/tiny-ssg)

No "configuration". All code. You have to assemble the libraries from npm to
make anything useful out of it though. Good luck.

------
drumvc
Self-promotion warning. I wrote a blog on converting my static site from
Jekyll to Gatsby: [http://unlikenesses.com/2017-11-06-migrating-blog-to-
gatsby](http://unlikenesses.com/2017-11-06-migrating-blog-to-gatsby)

------
arkadiyt
For building the site I use Jekyll with a free theme I found online + some
minor CSS modifications. I wanted to have js/css bundling/minification and
html minification, but after spending an entire day trying to get webpack to
work I gave up (what a joke). Instead I use a Rakefile that runs `jekyll
build`, then does some bundling/minification - it works great.

For hosting I use cloudfront -> lambda -> s3. There is a lambda for incoming
requests that handles some routing, and a lambda for responses from s3 that
applies various security headers (HSTS, CSP, X-Frame-Options, X-Content-Type-
Options, Referrer-Policy, Expect-CT, X-XSS-Protection).

I also have certbot (an ACME/LetsEncrypt client) running in a lambda once a
day - if my TLS certificate has < 30 days remaining it will provision a new
one and import it to be served by Cloudfront automatically.

The whole thing is serverless, can handle arbitrary amounts of traffic & is
very fast, and no maintenance at all. It costs me about $1.50 per month.

~~~
alexbilbie
You can use AWS Certificate Manager to generate a free auto-renewing
certificate and associate that with your CloudFront distribution.

Will simplify your stack a little by removing the LE step

~~~
arkadiyt
At the time that I built it ACM only supported email verification. Also I'm
quite fond of LetsEncrypt :)

------
segf4ult
I tried Jekyll and hated it. I didn’t find a static site generator I liked
until I found Ivy.

[http://mulholland.xyz/docs/ivy/](http://mulholland.xyz/docs/ivy/)

I use it for all my sites now.

------
ggurgone
Feel free to clone mine [http://giuseppegurgone.com/the-blog-about-
nothing](http://giuseppegurgone.com/the-blog-about-nothing) (instructions are
in the blog post)

------
snehesht
I wrote one a while back. It uses git, webhook to auto publish blog posts.

Here's the git repo
[https://github.com/snehesht/blog](https://github.com/snehesht/blog)

~~~
_eht
Nice. I'd be interested in opening a PR for the 'Social Buttons ( HN, Twitter
)' in your todo-- Do you still maintain?

------
kthejoker2
1) the number of people who write their own is amazing(ly ridiculous.)

2) what about for non developers? I can't get my sister to start using SCSS,
much less Docker or GitHub. The 2018 version of Frontpage or Dreamweaver ...

------
y4mi
Urm, you've basically described Jekyll with your requirements.

You do realize that Jekyll themes are basically just finished projects people
use because they can't believe bothered to create their own site, right?

------
ck3g
I've started blogging not that long ago. I'm using jekyll and GitHub pages.
Works fine so far for me.

[http://whatdidilearn.info](http://whatdidilearn.info)

------
theknarf
I'm using Webpack, and a Travis CI script to build everytime I push to the
main branch. Works fine, no need for a fancy "static website generator",
Webpack got you covered.

------
xrd
Blog.TeddyHyde.com. Do it all from your Android phone, create and write blogs
right into GitHub and add cryptocurrency micro donations.

------
argonauto
Ghost seems rather simple and configurable:
[https://ghost.org](https://ghost.org)

~~~
jarofgreen
I thought Ghost was dynamic. Does it have a static mode?

------
EngineerBetter
Hugo plus Cloud Foundry (Pivotal Web Services)

------
leksak
Tup, pandoc and rsync

------
lostmsu
I just fork Jekyll Now on GitHub and go from there.

------
Hoasi
Jekyll + Tachyons CSS

running on GitHub Pages + Netlify

------
moltar
Gatsby + Netlify

------
RobGav
Use Publii ([https://getpublii.com](https://getpublii.com)) With GUI and
themes, supports GitHub Pages, Google Cloud, S3, Netlify, SFTp. WP migratator
available too.

------
RobGav
Use Publii (getpublii.com) It comes with GUI and themes, supports GitHub
Pages, Google Cloud, Netlify, S3, SFTP.

