Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: What is setup for your static blog generator?
70 points by chauhankiran on Feb 10, 2018 | hide | past | favorite | 90 comments
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/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.

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?

I am looking for following things with setup:

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




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://gitlab.com/

* https://www.netlify.com/


Anyone who’s been keeping up with Jekyll (3.7.2) and Ruby (2.5.0) releases has experienced fairly noticeable speed increases without having to change much of anything.

The goal is to have Ruby 3 run 3× faster than Ruby 2.0; Ruby 2.5.0 is at 165% of Ruby 2.0 right now: https://appfolio-engineering.squarespace.com/appfolio-engine...


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") }}?


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.


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.


Is it possible to use scss and slim with Hugo? Does it support partials, an equivalent of liquid, investing data files?

These are the things that keep me with Jekyll and middleman.


It doesn't look like Hugo supports scss, so you need to use gulp for that: http://danbahrami.io/articles/building-a-production-website-...

You can run "gulp watch" to compile the files into /static, and Hugo's live reloading will pick up the changes.

I can't find anything about slim templates. "Hugo uses Go’s html/template and text/template libraries as the basis for the templating.": https://gohugo.io/templates/introduction/

It does support partials, and the go templates are similar to liquid.

I honestly don't do much to customize Hugo, I just pick a theme, tweak the CSS, and write some blog posts. If you have a Jekyll blog with a lot of custom Ruby, then it might be difficult to switch.


Thank you. I think I’ll remain with Jekyll and middleman for now as I am quite familiar with both.


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/


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.


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.


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

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


same here, I had created my custom themed html templates and css for pelican, but recently moved everthing to hugo. Complete control, no third party dependencies, no javascript (outside of pages with ttyrec recordings) and extremely fast to regenerate. Note this does assume you do your css preprocessing/minifying outside of Hugo though (I use compass), from Hugo's perspective your css is just another file.


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


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.


This is brilliant information. Thanks for sharing it.


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.


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


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.


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


I use Jekyll, super easy and aesthetic


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'm very happy with using pelican for my 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


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


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


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

- [1] http://themes.gohugo.io/

- [2] https://pages.github.com/

- [3] https://www.digitalocean.com/

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

- [5] https://www.robinwieruch.de/deploy-applications-digital-ocea...


I wrote my own for 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.


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 ) 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 ) & Docsify, etc...

Then now. Personal opinion but I love Gatsby ( 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.


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 use Gutenberg (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 ) 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.


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/). 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/) which is very similar to Jinja2.

I then automatically build & deploy from 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...) 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.


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


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
is a nice simple way to push your build directory to the gh-pages branch.


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

Yes please. I need to support localisation on a site I maintain, and for that will need one (or more) plugins that github don't support so would be interested in your setup.


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


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/


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.


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.


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


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://pandoc.org/


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


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


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

There are many good themes for Hugo (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)


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.


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.


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)


I use pelican. It is quite similar to jekyll, but it is python based. https://blog.getpelican.com


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


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


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/), but didn't get to "blogging" until now :)


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.


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


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

* https://getnikola.com/

* http://ontoblogie.clabaut.net/en/posts/201801/use-nikola-gae...


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.


I'm very surprised no one has mentioned GatsbyJS yet 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.


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


There is a documentation how to host 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/


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


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


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?


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)


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


I am using Jekyll, Heroku and Git and here are instructions: http://www.reluctantwriter.in/dev/how-to-start-jekyll-powere...

Please let me know if you need help.


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.


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.


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


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.


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


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


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.


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


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


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


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


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?


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

http://whatdidilearn.info


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.


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


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


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


Hugo plus Cloud Foundry (Pivotal Web Services)


Tup, pandoc and rsync


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


Jekyll + Tachyons CSS

running on GitHub Pages + Netlify


Gatsby + Netlify


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


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




Join us for AI Startup School this June 16-17 in San Francisco!

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: