a very small static site generator
Go to file
2021-01-30 15:35:12 -06:00
I Move TM to L; change I/ file names 2021-01-30 15:28:28 -06:00
S Add CONTRIBUTIN section (and a gif\!) 2019-07-01 20:06:43 -05:00
.gitignore Add .gitignore 2019-06-30 23:43:06 -05:00
L Move TM to L; change I/ file names 2021-01-30 15:28:28 -06:00
lht Change order to allow inline on ends of p 2019-07-01 12:37:58 -05:00
LICENSE Add README and LICENSE 2019-06-30 23:42:27 -05:00
README.md Update README 2021-01-30 15:35:12 -06:00
unk Change spacing 2021-01-30 15:31:45 -06:00


a very small static site generator

UNK is an experiment in minimalism. It is a templating static site generator with an included markup language that all fits within 1000 bytes. There are three main scripts:

  • UNK (239 bytes), a POSIX-sh script that applies the template to each page and publishes them to the output dir,
  • LHT (241 bytes), an awk script that serves as a (very) basic markup language, and
  • L (502 bytes), the default template script for UNK.

You are, of course, free to make the template file as large and involved as you like, but it's pretty good already:

  • it has a plain default CSS (based on this article), or will use S/s.css if it exists
  • it automatically adds a list of posts to the index page, or a link to other pages
  • it cleans up the first line of the input file and makes it a <title>, and a <h1> in the generated HTML



To install UNK, simply clone this repo and put it where you want it. The default L needs LHT to be in the same directory as it, so keep that in mind.

To run UNK, just cd into your cloned repo and run ./unk. It's just a POSIX shell script.



UNK takes a set of files in a directory, applies a template to them, and output them into another directory as HTML files ready for a server. To keep a very small size, UNK delegates most file processing to L, the main template. It delegates by using an idea found in shab: each input file is read as a heredoc, which enables shell interpolation. So the template, as opposed to the engine, can do all the heavy-lifting of index generation and navigation and such.

Content goes into the following (hard-coded) directories:

  • I/, for written (Input) content (the pages of the site),
  • S/, for Static content (css, images, etc.), &
  • O/, for the (Output) website, ready for rsyncing to a server.

If there is no L in the directory where UNK is run, one will be created that will simply cat the file being processed.

The following variable is made available to L:

  • F: the File name passed to L
  • N: the fileName (with directories removed) of the file being processed

as well as these functions:

  • X, for eXpand: the shab stand-in. It is much simpler than shab, and will fail if the template (or if it nests templates, one of the nested ones) has a ^D on a line by itself, due to its heredoc nature.
  • T, for Title: it'll return the first line of the current file.
  • B, for Body: it'll return all lines *but* the first of the current file.

and these aliases (though they're more an artefact of saving space in the script, but they can be used in templates):

  • c: cat
  • q: test
  • e: echo

As mentioned above, templates can be nested. Simply call another template from L with the X function.


LHT stands for Less HyperText, because that's what you're writing when you're writing it (though not much less than HTML). Basically, blank lines are interpreted as <p> tag breaks, unless the previous source paragraph started with < and ended with >. It also has support for three inline spans:

  • *em* as em
  • __strong__ as strong
  • `code` as code

Everything else is just HTML. This means that a valid .lh file is almost a valid .md file, except where it nests HTML and Markdown (so it's not really, but you can run it through Markdown in a pinch and get the basic idea across. This file, for example, is both index.lh and README.md (they're just symlinked to each other), so it's got some weirdness to keep things compatible between Markdown and LHT. But if you're just writing for LHT, it can be much simpler.).

LHT was inspired, in part, by Writing HTML in HTML by John Ankarstrom, as well as some other articles I can't think of right now. I liked the idea, but some tags in HTML are just annoying to write over and over, and take me out of the flow of writing prose. So I fixed those few tags. The inline tags are definitely subject to change.


I was bored and decided I'd try to write a static site generator that could fit in a toot (500 characters). I wrote a few of them, making them smaller and smaller each time. By the end, I was left with a tiny script that delegated almost all the work to the template file. That script became UNK in this repo.

I was feeling pretty high on my horse after writing the tiny SSG, so I thought, maybe I could try for a tootable Markdown converter next — boy, was I wrong about that. Markdown is way too complicated to fit in 500 bytes. So I just wrote the Really Important Parts: <p> and some inlines.


Copyright © 2019 Case Duckworth <acdw@acdw.net>.

This work is free. You can redistribute it and/or modify it under the terms of the Do What The Fuck You Want To Public License, Version 2, as published by Sam Hocevar. See the LICENSE file for more details.

Why this license?

I was going to go with a stricter license like the GPL, but realized that

  1. this software isn't so important or time-consuming that I need others to credit me or redistribute the project under the same terms, and
  2. the GPL is way too long for a project like this. It's over 35 times bigger than the entirety of this project, not counting the content or this README. It would weigh down the entire undertaking. The WTFPL, by contrast, is a trim 443 characters, which is right in keeping with the smallness of this project.


To contribute to this project, head over to its GitHub mirror and send me a pull request or issue. One of these days, I'm sure I'll figure out sr.ht's mailing lists, Meme of Aragorn saying, 'But it is not this day'