GNU M4, rsync, and a 12-line makefile: https://p.hagelb.org/Makefile.html

no regrets

I was appalled at the scarcity of static site generators out there. So I wrote my own: Glod, the new glod standard in static site generation.

I’m using writefreely for my chargen blog, which is an open source version of write.as. C1’s in closed alpha for now while I bend my head around the codebase, but the plan is to create a place where people can:

• Write about things that interest them
• Federate everywhere (RSS, Activitypub etc)
• Read the content without popups or tracking
• Read content the way they want to (Gopher, FTP, epub, audiobook)

So far I have the basic writefreely working on OpenBSD, which wasn’t easy as it’s a young product and OpenBSD isn’t supported. RSS works, activitypub isn’t working as well as I’d like. Working on templates and gopher support at the moment.

If that’s something that tickles your fancy, drop me a message and I’ll send you an invite so you can poke around and see if it’s for you. Write.as is mighty fine though.

I use Octopress to do static site gen for angersock.com. I’m still not happy with it, and will probably switch to some homebrew markdown nonsense.

My criteria are basically:

• Static site generation (because admin is much easier, and performance is much better)
• Markdown support (because formatting is annoying and I’d like something simpler
• Code snippet support
• Image support
• Git versioning
• Simple deployment
• Be able to self-host it completely–no other domain traffic (which is broken by the styling on the site atm)

Things I sorta care about that aren’t dealbreakers:

• Ability to blog using email
• Slug creation for articles
• Landing pages
• Organized story indexes and tags
• RSS feed generation
• Code size

Things I don’t need/care about:

• Support for comments (that’s what email is for)
• Support for heavy javascript stuff/flashy animations
• Analytics (if I care, I’ll crawl logs)
• Easy plugins
• Easy theming
• AMP

i recently learned that GitHub supports AsciiDoc

https://github.com/github/markup

So I am working on converting all my Markdown to that - markdown has gotten stale and doesnt seem to be any desire to evolve the spec

https://github.com/commonmark/CommonMark/issues/558

and while Markdown is good for basic Readme i feel its unable to handle more robust documents, forcing users to fallback partially or totally to HTML - which defeats the whole point of using markup

https://asciidoctor.org/docs/asciidoc-syntax-quick-reference

Don’t worry to much about what stack you’re going to use now. Start with something simple that allows you to write and worry about in depth tech later. Do a WordPress site, Ghost, God forbid Medium, a plain text file, gopher, but just get started. Write, keep that up for a month or two and then check your workflow.

Maybe for your personal brand a simple page with contact details and a resume is enough.

Or, if you like to tinker, go all in with static sites and other tech. But it will probably be more of a tinkering with the stack thing than a writing thing.

(Full disclosure: I started with Joomla in 2006, wrote my own PHP system in 2008) and in 2012 wrote a static site generator. Here is some history: https://raymii.org/s/blog/Site_updates_new_layout_for_overview_pages.html

I do update my generator often and write about it. Latest additional is a text only version of my content and accessibility improvements: https://raymii.org/s/blog/Site_Improvements_for_accessibility.html )

My https://two-wrongs.com uses Emacs to generate the HTML, and then nginx to serve it. I have used various systems through the years, but this is the one that really stuck with me. Emacs is flexible enough that I’m unlikely to outgrow it any time soon, and the language is convenient enough to script in. I really like it!

I wrote a little static site generator, because that seemed like more fun than getting used to anything else. It takes HTML bodies of posts, and wraps them, generates a homepage, and an rss feed. I’m currently in the process of using it for another site, and it’s been surprisingly enjoyable.

I’m using two different static site generators. Hugo is used for generating cli.fan and Pelican for generating my personal website. Hugo was a lot easier to get up-and-running with, Pelican’s configuration and directory layout was a bit less documented. I chose Pelican initially because I’m more comfortable with jinja2 formatting than golang’s built in template format, but that was only really important when developing the content templates.

I like static site generators because they keep the content simple and easy to cache. You could even host the results on github/gitlab if you don’t want to maintain a VPS.

I use Hugo: https://github.com/BurntSushi/blog

When I switched to Hugo from my own hand-rolled blog server, the biggest simplification I made was to just get rid of comments. They were never particularly productive, and there are lots of other sites, such as Lobsters, where folks can comment.

I’m mostly happy with Hugo. My main concerns are mostly 1) providing decent syntax highlighting on code snippets and 2) make sure the code I include in the blog post is checked and tested. The latter part is a bit of a pain, but I’ve mostly been able to skirt by via writing my own Hugo shortcodes and scripts to extract code snippets. It’s pretty much all bailing wire and duct tape at this point.

I use netlify and gatsby. It’s very cool, but it’s a bit too much for me. At some point in the near future I’m going to go to something simple.

I use hakyll and serve the files up using caddy. I would normally reach for nginx, but caddy’s easy of use (in particular built in https from letsencrypt) won me over.

I use WordPress for https://www.datafaber.com because by now I know it well enough to have built a decent semi-automated workflow for updating it and backing it up. I have 4 other sites running on it and in a former company we ran a high-traffic site where WordPress served ~ 90% of the pages.

About a year ago, there were threads here where two small but elegant static site generators were mentioned…

• Ivy: https://github.com/dmulholland/ivy/blob/master/readme.md (demo) – Lobsters thread
• Athena: https://github.com/apas/athena (demo) – Lobsters thread

After trawling the showcases for Hugo, Jekyll, and other static site generators, I keep coming back to these two beauties. I currently use Ivy for an online resume, and plan to use Athena for a blog. Ivy is a breeze to install, but Athena requires quite a lot of tinkering with its dependencies (see the Athena thread above for details on what I did to get it working on Fedora 29).

I use Cryogen, it’s a static generator that works with Markdown or AsciiDoc, and supports publishing to GitHub pages.

I’m using my own blogging engine that I first wrote in 1999 [1]. It’s in C (because I’m that crazy like that). I still write pretty much raw HTML because I find that easier than memorizing what Markdown (or Markup or whatever it’s called these days) will generate. The pages are dynamically generated except for the index.html and the various feed files [2]. I also have multiple methods for adding new entries, including via email (my preferred method actually). My blog is also available via gopher.

[1] Not a single line from then exists in the current code base, but the data format hasn’t changed at all.

[2] Those are statically regenerated per entry, on the assumption that they would be referenced more often than individual posts [3].

[3] You can specify an arbitrary range of entries in either order, which is something I’ve never seen any other blogging engine implement.

I’m using Hakyll (Jekyll, but Haskell) to generate http://sulami.github.io, with the twist of also outputting symmetric PDF via LaTeX in addition to HTML for my CV. Actually, there’s a post about this: http://sulami.github.io/posts/how-this-blog-is-made/

Sort of on topic: someone (I don’t know who, but I like it) aggregates a bunch of lobste.rs users’ blogs here: https://crustaceans.hmmz.org I check it out every now and then.

Bashblog

Markdown + bash https://github.com/cfenollosa/bashblog

I wrote a static site generator in Idris. I was going to experiment with using dependent types and proving things about the site generator but I never got around to it. It really just concatenates lots of strings together. Not great.

What - Lektor

Why - I wrote about it on my blog. I like its simplicity so much.

By the way, email subscriptions are coming to Write.as this month 🙂 (founder here)

Jekyll because that was what everyone used but I’m planning to switch to https://www.getzola.org/,

I also used https://github.com/Ceasar/staticjinja for some smallish sites

Used Zola a little bit and it was great.

http://loup-vaillant.fr/projects/ussm/

A little late but what the heck.

I used a static site generator previously and was missing a comfortable way to have draft post while still be able to have a link to share it with others (a secret link to a draft post if you will). Ghost is perfect for this. I think it’s the right spot between static site generator and a full blown CMS. I’m using it in docker container behind a Caddy proxy and it is super fast. It feels at least as fast as the static site version I had before (no benchmarks though).

You can also easily invite others to work with you on your posts via the easy to use admin frontend (which by default is available via /ghost on your blog).

I had to edit the default template to reduce the calls to external sites to a minimum (the RSS feed URL wraps around feedly.com for whatever reason) but that was very easy.

I can really reccommend it for personal blogs!

wordpress.com since ~2006.

Static site generator. I use a Python script of 256 lines, rsync, and the vhost of a friend.

Before my selfmade script I used ikiwiki. Parts of my website are still generated that way, but it was not flexible enough for me. I’m also using restructuredText because Markdown is not extensible with custom stuff.

If I would decide to add some newsletter signup, I would either use some third part Javascript embedding or a simple PHP script writing to a text file.

I’m currently using Pollen. It is pretty neat :) https://docs.racket-lang.org/pollen/ It’s intended for books, but I could see it easily being used for writing and publishing blogs, like this one: https://thelocalyarn.com/excursus/secretary/

I am dogfooding my own forum-like system, which builds a static site from txt files into HTML, but still allows updates through web. Links in profile.

Edit: Seems like many people are using static site generators. What makes mine different, among other things, is PGP-backed user accounts, client submissions through HTTP via the access log, and high priority on accessibility, including support for textmode, nojs, and old browsers.

I use Jekyll for bernsteinbear.com because it’s pretty simple. I am slowly growing frustrated with the large Gem dependency graph and may eventually switch to something with a lower footprint. That being said, I don’t much notice it because GitHub Pages generates everything for me.

I used Jekyll for many years but finally replaced that with a custom static site generator written in Haskell and which uses Pandoc to convert Markdown. I was getting bad performance out of Jekyll, mostly because of the self-inflicted wound of running it in a Docker container. (I got sick of the constant churn in the output that Jekyll produced for a given input, and putting it in a Docker container meant that I could specify exactly which versions of Jekyll and its plugins I wanted to use. That also allowed me to get rid of my system-level installation of all the necessary Gems.)

Writing a custom generator was a bunch of work, but it was an enjoyable experience that taught me a lot. Jekyll was pretty flexible overall but this program does exactly what I need.

(Also, I assume you already know this, but you’re not going to have any plausible deniability if you’re hosting both personal and professional sites from the same personal server. The two sites would share an IP address but no other site on the internet would use that address.)

I keep a photoblog (https://charczuk.com), and use a static site generator I wrote for it (https://github.com/wcharczuk/blogctl), source for the blog is here (https://github.com/wcharczuk/charczuk.com).

One key thing, deploying to S3 and fronting with CloudFront lets you use free certs managed by AWS.

I like sblg by @kristapsdz

For my personal blog More Magic I use Hyde, which I love because I can use Scheme to customize it. I don’t have the energy to put up with languages that I find inelegant or boring in my free time. Besides, by eating my own dog food I can feel the pain myself if there are bugs in CHICKEN or any of the eggs I wrote that Hyde depends on.

“Another part of me would like a tiny letter style digest sign up as well. write.as seems to be a great place to do this. Though there isn’t any kind of subscription option.”

I haven’t used it, but perhaps consider substack? Feel like I’m seeing journalists using it to launch side projects/build their own mailing list - it seems to have a medium-like reading experience for permalinked mailing list entries.

For my personal site I’m using wintersmith and s3_website. Desired it more for wanting something more open-ended than ease of use though.

Not that I blog much, but I use Github pages and whatever markdown generator they suggested in the setup instructions. EDIT: Now I remember. I had to install Jekyll and then copied https://github.com/poole/poole as the base layout.

It’s okay, but I don’t understand the obsession with markdown. It’s been on my todo list for a while to move back to plain HTML because it’s easier to deal with.

I tried to use some of the generators out there (I fought with Jekyll for a long time, and then something else for less time but I can’t remember) and just got frustrated at how complicated they were and how hard it was to get them to look the way I want. Now I use bash and either hand-written HTML or commonmark with cat for a templating system, depending on the page. I understand it completely and love it dearly.

I love how so many folks are using their own home-rolled blogging system. I’m tempted to write my own now! I’ve been using Jekyll to build a blog served by nginx. But I’ve been itching to try Gatsby.js, but I think I get enough React at work. :)

Python glued together with Unix tools :)

http://www.oilshell.org/site.html

I use “HTML” for writing the page, IPFS+Cloudflare for distribution. Pinning the website hash on a raspberry pi.

Edit: Using gandi’s cli to update the dns record.

Most of my sites are built with the static generator Nanoc that’s written in Ruby, is superbly friendly, lightweight and easy to tweak. Loving it!

Not that I blog but these days it’s hugo for pesonal sites…. in the past I’ve used Jekyll. Before that I wrote my own in Java using Velocity for templates and I think I even experimented with m4 way back in the day.

Wordpress, with a couple of plug-ins that let me MathJax and Markdown. I took almost all of the browser JS out of the served pages, except the MathJax where I need it.

[Comment from banned user removed]

I’ve been using Publii that uploads to Netlify, but I don’t like it, and it’s always been meant to be temporary anyway.

I’ve played with Hugo and other static site generators, but I could never find a theme that worked for me. My next step is to move to straight HTML and continue uploading to Netlify until I find something better. I’m a bit of a control freak over my formatting, especially since I have lots of code examples, which nis why a lot of the themes haven’t worked for me.

If I get sick of writing HTML directly, then I may throw together my own static site generator in Java just for educational purposes, not because I think the world needs another one..

Python mkdocs has been doing me pretty well. Not for blogs but for just static sites. Could easily be used for blogs though. It’s pretty straightforward. Not as many bells and whistles as things like Jekyll and Pelican. But that’s one of the reasons I like it as well as it live reloads the page in the browser while you’re editing locally in markdown and use ‘mkdocs serve’ which is just python tornado under the hood. Then it’s just ‘mkdocs build’ and upload the folder wherever it’s going (mine are all in s3 buckets).

For more complicated stuff I use Sphinx for the diagramming plugins, etc… simpler the better I think. Previously I just had a couple hundred lines in python to convert a directory of markdown using jinja2 templates.

I use POSIX sh and GNU make, as described here.

I use a custom CMS I wrote in Go. That’s admittedly overding it in some ways, but it’s worked well for me.

GatsbyJS is what I’m using for mine. I’m really happy with its support for stuff like building a TOC and listing of posts at compile time by querying the list of files on the website and stuff like that.

The majority of the action happens in this simple file: https://github.com/Ameobea/homepage/blob/master/src/pages/blog.js

All I have to do to publish a new blog post is create a markdown file in the blog directory, add a small header with a title and date, and then push the changes up to Github. I’ve got CircleCI configured to automatically build a fresh version of my website and rsync it over to my VPS where it’s hosted live via Apache2.

[Comment from banned user removed]

I use vuepress hosted on GitHub pages, with a custom cname. Happy with that setup for now.

WordPress.com,since 2011. It’s fine for my needs, no big complaints.

Currently I use stackedit.io to write stuff. I then generate static html from this. Works, but I’m not completely happy with it, especially becaise there is no nice way to preview images and add captions and footer text.

About two years ago I switched away from Octopress with org-octopress on Github pages. It turned out to be so hard to migrate from Octopress 2 to 3 that I scrapped it all and switched to Hugo.

Advantage: Hugo is much faster. I’ve only got a few hundred posts. Hugo builds in less than a second. Octopress was taking 50 seconds or so.

I also moved from GH pages to Netlify for no especially good reason. Netlify has a somewhat nicer (read: easier) interface for staging builds.

Blogspot.

Because I don’t want to waste upload bandwidth to serve pages/images.

Also, I can post a page (including images) using e-mail, and a Ruby script to send that email.

I briefly considered writing a concise program to transform a notation into HTML, but I didn’t know enough HTML and so abandoned the idea permanently.

My website is here: http://verisimilitudes.net/

I simply write it all by hand. This has, unfortunately, lead to me becoming more and more familiar with HTML and its various deficiencies, but has the advantage that my website looks fairly unique even with minimal formatting, as any new effect I want to accomplish I learn how to compose and then build in my own way, often using previous effects from other pages. The CSS is inlined with each page because I observed at least one tool that prevents CSS from being loaded does nothing to inlined CSS and I found that a worthwhile reason to avoid including it from elsewhere.

All of the SVGs are also written by hand, but I’ll be using a program of mine to process and transform from my own format soon enough. I simply need a tool for writing that other format, first.

Lastly, I include an HTML presentation of the output of one of my programs. I transform it manually, but writing the articles has made me reconsider having tooling that generates formats, such as HTML and TeX, to spare me from doing it.

An advantage of this style of website is all I need do to set it up is dump the files into the correct directory for the HTTP server.

[Comment removed by author]

Wrote my own static site generator, mostly for usesthis.com, because of course I did.

https://github.com/waferbaby/dimples

Using Jekyll and GitLab but been considering a cleaner codebase and maybe contribute something. Hugo is the one I’ve been thinking.

A really dumb Racket script, git and github pages. Posts are simple markdown files in a folder. If I add a new file it doesn’t get picked up automagically; I have to explicitly add it to the list of posts (which is written directly inside the Racket script) and specify its filename, title, date, and tags (though I don’t do anything with those yet). All non-post pages, layouts and RSS/Atom feeds are xexprs inside the Racket script. When I need to add an image to a post I just drop it in the images folder and link it from the markdown.

I also kinda want comments or just a guestbook so perhaps at some point I’ll rewrite it in Ur/Web or OCaml and while I’m at it turn it into a sort of personal wiki with some public pages, but for the moment I’m fine with this setup.

I really like static site generation, but they make it hard to update content while you’re on the go. I don’t have any dedicated hosting, so I wanted to use Github Pages as a hosting solution. I built a quick and really dirty solution that fits me, named tibl. I update my posts directly on github, and they are rendered client-side by marked.

AzerothJS and CMS.js are projects that follow this fashion (and seem to be way better).

Started with Jekyll, immediately regretted it. Moving to custom Typescript script + React as a templating engine.

I’ve been using Blosxom in static mode for many years.

I’ve been using Squarespace. It’s expensive, but I can focus on writing and content versus building my site.

Wellll…..

jkirchartz.com uses GH-Pages/Jekyll

But I’m hosting my vimwiki (which is actually powered by vim-waikiki now) which could easily be used as a blogging platform.

But also, with pandoc it’s trivial to use Unix as a CMS with markdown files that I use on tilde.town

A little opinion: by using static site generators, we are giving up the power of the computer as a dynamic medium. The computer can be far more than just a way to read linked documents. A few ideas: allowing users to come up with their own views into the corpus, sites that pull in several sources to make one article dynamically, etc. We need to think bigger!

Ox-Hugo: https://ox-hugo.scripter.co/

For my blog I use Hugo on Netlify. For some other static site projects I’m still on Middleman.

GitHub Pages works just fine for me. Combined with VimWiki to take notes.

https://github.com/zimbatm/wiki

I previously wrote my own blog platform in XQuery that rendered HTML dynamically on the server side. Each blog entry was written in a subset of Docbook.

After many years I got tired of maintaining it and instead wanted something that allowed me to focus on the content rather than the platform. I installed Ghost on my own sever and am super happy with it. I use the Electron app for authoring, which gives me a very simple content first experience and supports Markdoen when I need it.

Pelican because it has a good design and staticsite because it does not force you to follow a rigid directory layout.

I write in Markdown and use pandoc to convert it to HTML. I made a couple of scripts (“panpipe” and “panhandle”) which allow code embedded in the source to be executed during rendering. I generally write about programming stuff, so this is useful to ensure that code snippets actually work (execute them during rendering and abort if they’re broken) and that example output is accurate (generate the example output from the actual code during rendering).

I used to generate the site using Make, but the Makefile got too hairy for my liking. I now use Nix, which has the bonus that each page can specify if it wants any extra packages available during rendering (for embedded code to use). I’ve recently spent some time simplifying the rendering scripts, which had built up special cases and whatnot from their Make days.

I send updates using rsync and use the darkhttpd server.

I used to push things to IPFS as well, but got fed up of their daemon hogging so much RAM and CPU that I’ve given that up for now.

Jekyll with AsciiDoc. I’ve been satisfied with it so far. Using the asciidoc plugin required me to use a custom Travis CI job to build the HTML and to display it on github pages, but this was fairly easy. My needs are rather basic:

1. chronological display of ports, static pages, RSS
2. support for graphviz, plantuml, ditaa, svgbob
3. latex and bibtex support
4. advanced markup with footnotes, easy cross referencing, things that markdown lacks
5. live preview (not that important)

All of these are covered by jekyll-asciidoc combined with asciidoctor-diagram.

From all alternatives out there, I think org-mode comes really close, but the problem is that it would require a lot of elisp magic to get even 1) done easily, and 5) is not needed since org is fairly WYSIWYG.

On the other hand, editing org-mode is amazing. Emacs AsciiDoc plugins are not very good, so I rolled out my own. Things that are bad with jekyll-asciidoc and Emacs:

1. Adding links sucks. It requires Liquid templating like {{ post_url 2019-09-02-foo-bar-baz }}, I’d rather just use org-insert-link with autocomplete from org files in the project.
2. Editing code blocks is nothing like using org-babel – being able to use the major mode for the language in the same file is amazing
3. My asciidoc major mode sucks (did I mention that already?)

So perhaps I should just invest in Org more, or improve my asdiidoc major mode.

I wrote my own. I wanted something that would allow me to use $EDITOR to compose in a pseudo-LaTeX syntax to separate content from presentation but at the same time allow readers to leave comments.

On a technical level, it uses a bunch of files and directories to store the posts, comments, and metadata. It is a C daemon that processes SCGI requests from a http server (e.g., nginx).

At the moment, it assumes that you are running on Unleashed/illumos, but it should be easy enough to replace the event ports code with kqueue/epoll/whatever.

source: http://hg.31bits.net/blahgd/ & http://hg.31bits.net/libjeffpc/

Currently using Bludit. It’s low maintenance with no database and I made a javascript-free theme. I’ve run various other blogging systems but often decided that they were too complicated to maintain.

In an effort to try to find the minimalist blog possible, I rolled my own. It’s a static site. It’s all static using Vue.js but there’s an an AirTable back end that delivers json files that are used for the content (which you can set up various ways, chron, pub-sub, on-demand, etc). It’s all auto-deployed on S3. No server, no engine (aside from a small amount of JS code powering Vue), no software to update or maintain but you still have everything you’d get from a Wordpress. I’m expecting costs to be zero or pennies, and it should scale up as far as I’d want it to.

You can read about it here: http://tiny-giant-books.com/Entry2.html?EntryId=recXmHgxSFwTTZy1t

It was a fun project. I’d try to make it even simpler, but this is as far as I could go while still keeping the normal stuff you’d expect with blogging like plugins, themes, markdown, images, and so forth. I don’t know how you could go further down that route. I mean heck, anybody could write a script to post html files to a server. Perhaps the real trick is determining just what you mean by “blog”?