Ask HN: What is setup for your static blog generator?

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

makefile + rst2html

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

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.

This will probably forever be too half-baked to "release", but I wrote my own: 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.

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".

I run 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.

    git subtree push --prefix build origin gh-pages  
  

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

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.

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

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...

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.

We use 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.

I use Hugo (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.

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/

* Kickstarted in 2013

* Markdown-based

* Open source, self-hostable

* Hosted solution (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/lexoyo/static-ghost)

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

Ghost seems rather simple and configurable: https://ghost.org

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.

Hugo plus Cloud Foundry (Pivotal Web Services)

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

Jekyll for my podcast's web site (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/) 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.

I wrote one for node: 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.

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

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.

We've built a whole UX toolkit (shameless plug: 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

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/

I use it for all my sites now.

We use 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/