Vydání o tom, co se stane, když se něco pokazí. Každá stránka, feed a index se teď zapisuje do dočasného souboru a přejmenuje na místo, takže uložení přerušené plným diskem nebo sestavení zastavené uprostřed zápisu už nezanechá stránku v poloviční délce ani příspěvek o 0 bajtech, u kterého je starý text pryč. Studené sestavení tím zdraží zhruba o pětinu; sestavení z cache ne, takže běžný den publikování stojí přesně tolik co dřív.

Dvojí doručení už neznamená, že se něco stane dvakrát: příspěvek odeslaný z telefonu dvakrát nebo jedna potvrzenka doručená ve dvou kopiích najednou je teď jeden příspěvek a opětovný import exportu vlastního enginu už z 1200 příspěvků nedělá 2400. A adrese se už nevěří jen proto, že jako adresa vypadá — ../ ve slugu, v názvu mediálního souboru nebo v cíli přesměrování zůstane uvnitř webu, lokální nasazení zůstane uvnitř svého adresáře a přesměrování z feedu nemůže poslat stahování na localhost.

Před tagem prošlo pět úzce zaměřených revizí zápisové cesty, výstup sestavení, import a export, check a série; všechno, co našly, je opravené a přišpendlené testem, který na starém kódu padá. Většinu z toho nikdo nikdy nepotká. Co potkat můžeš: check se ptá na totéž co sestavení, takže stránka se slugem index.html už nezastaví každé sestavení, zatímco check prohlašuje archiv za v pořádku; export se už nezastaví na prvním rozbitém příspěvku a vrátí se domů i s prázdnými odstavci a vloženými prvky beze změny; série o dvaceti a více dílech se otevře od prvního dílu; a díl s číslem 08 už o své číslo nepřijde kvůli osmičkové soustavě.

Není co migrovat — git pull, sestavit, nasadit. První sestavení vykreslí každou stránku jednou; na mém vlastním archivu o 6 600 příspěvcích nahrálo následné nasazení jediný soubor, tahák k Markdownu. Celé poznámky →

It had been waiting for the index.

Why it sits at the end

An MP4 is a handful of boxes laid end to end. One of them, mdat, is the picture and the sound. Another, moov, is the index: which frame is at which byte, how long the thing runs, what codec to hand it to. A player needs moov before it can show a single frame.

A recorder cannot write moov until the recording stops: until then it does not know what will be in it. It writes the picture first and the index last. Every phone does this, and so does the share sheet that repacks what the phone recorded. The file is correct and it plays. It only makes the reader download all of it to see the first second.

Moving that index to the front is one flag of one program. What was missing was anything in the engine that knew the question existed.

Reading where it sits

lib/video_probe.rb walks the file's top-level boxes, reading the four-byte length and four-byte name of each and seeking past the body. No ffprobe, no gem -- the same box walk that already reads a video's frame size. If moov comes before mdat, the file starts fast. If it comes after, it does not.

A counter around File#read, on a forty-megabyte file with its index at the end: twenty-four bytes. Three box headers. The forty megabytes between them are never touched.

It answers nil, not false, when the question does not arise -- no moov, no mdat, nothing it can parse. "I cannot tell" and "badly ordered" are different answers, and running them together would report a fault about every unreadable file. The walk also refuses to descend: an mdat is full of bytes that can spell anything, including a box header spelling moov.

Moving it on the way in

media: remux_video: true in config/site.yml, and the engine repacks a video as it is attached:

ffmpeg -nostdin -loglevel error -y -i IN -c copy -movflags +faststart OUT

-c copy is the whole of it: the picture and the sound are copied across as bytes, nothing re-encoded, nothing decided about quality. +faststart writes the index first. A QuickTime .mov comes out .mp4 while it is there, because some browsers decline the container whatever is inside it. An .mp4 that gets repacked comes out 01-web.mp4 rather than 01.mp4: the same name is offered when an author runs ffmpeg by hand, and ffmpeg refuses its own input.

A repack counts as done only if ffmpeg left cleanly and left a file with bytes in it: a tool that dies halfway leaves a truncated file and can still exit happy, so the status alone is not an answer.

This was exercised against thirty real videos out of a working archive with ffmpeg 7.1. Three carried the index at the end. All thirty came out fast-start, and every one kept its duration, which is what proves the copy is a copy.

The ones already in the archive

check opens the videos an archive already holds and names the ones with the index at the end, by post and by file:

klip: the video 01.mp4 carries its index at the end of the file.

Beside each it prints the repack command -- in outline, with FILE where the name goes -- and the setting that does it on future saves. It is a warning, not an error: check leaves with zero and counts it worth a look rather than a problem. The file is not broken. It is slow, and slow is the author's to decide about.

On a save the same sentence appears only where the two older notices have nothing to say. An HEVC clip and a .mov already come with a command that moves the index as a side effect, and a third command for one file is a third thing to weigh.

What it refuses to do

It needs ffmpeg and does nothing without it. With the setting on and no ffmpeg on the machine, the save says the repack was skipped and stores the file as it arrived.

A repack that fails is not a refusal either. The post is saved, the video goes in as it came, and the author gets the sentence they would have had with the setting off. That is the difference from the HEIC conversion, which does refuse: a HEIC photo displays in Safari and nowhere else, while a video in the wrong wrapper still plays for nearly everybody.

check fixes nothing. It prints the command, and running it is a person's job.

It is off by default, like everything else here that shells out to a tool the engine does not ship.

What it costs

Installing ffmpeg once. On save, the time it takes to copy one file: the cost follows the size of the video, not the length of an encode that never happens. And nothing on the archive already on disk until the commands check hands over are typed, one video at a time.

1.7 puts fifty-five drawings in between, and gives each of them a name.

Fifty-five nouns

Counted in lib/icons.rb: the eight content types, fifty-five more, sixty-three names a tag may ask for. Grouped by what a blog turns out to be about.

• getting about — bike car train plane boat walk
• places and weather — map pin mountain tree sun cloud rain snow
• a day — coffee beer food wine clock calendar home heart star gift
• making things — pen brush camera film mic music book tools hammer
• machines — laptop phone code terminal server bug lock key
• living things — paw bird leaf flower
• ideas — bulb flag globe eye chart target rocket mail briefcase box

Plain English, and the word somebody reaches for first: bike, not bicycle. A footer link under social: can wear one too, where the network marks have nothing to offer: globe for somebody's other site.

Why they sit beside the eight

The same 24-unit grid, the same two-unit stroke, the same currentColor — the part that lets one drawing follow a light theme and a dark one without a second copy. All fifty-five carry round ends and round joins, because they are pictures of things rather than diagrams and a mitred corner on a two-unit stroke reads as a spike at twenty pixels. doctor holds a hand-written icon_svg to that same grid.

Where it turns up

Two places. The heading of the tag's own /tag/<name>/ listing, and the date badge of every post carrying that tag — where it replaces the content type's icon rather than joining it. A badge is a small tile with a date and one glyph; the only thing that ever adds a second is a pinned post, and a listing stacks ten badges under each other.

A tag is matched by its address rather than its spelling. Sci Fi in site.yml reaches posts tagged sci-fi and posts tagged sci_fi, because those are one page and therefore one tag.

The order in the list is the priority

tag_icons is a list, and the order in it decides. Most posts carry more than one tag, and the tag a post was given first is usually whatever an importer put there rather than a subject — so the first entry in the list that a post has is the one it wears, settled once instead of post by post. A post tagged sci-fi, coffee wears coffee if coffee stands higher, whatever order the post wrote them in.

Written as a mapping — kolo: bike indented underneath, the shape half of site.yml is in — it draws nothing, and it always did: until now with no warning from the build, and doctor calling the file sound. Both name the key now, and doctor counts it a problem and exits 1.

What it refuses to do

It is not a folder to drop drawings into. Everything under assets/ is copied onto the site wholesale, so a folder of fifty would publish fifty files to serve a site that uses two — and an icon is written into the page rather than fetched, so nothing would ever ask for them. The set is a Ruby hash for that reason.

The eight content names cannot grow without a content type behind them. And an icon_svg that is not a drawing at all — a filename, an address, an emoji — is refused rather than printed where the glyph goes; the tag falls back to what it would have had with no entry.

What it costs

A name the engine does not have draws nothing, and the build does not mention it: configure bicycle instead of bike and the site builds, exits zero, and every post that should have carried a bicycle keeps its content type's icon. doctor is what says so: it names the tag, the name it asked for, and prints all sixty-three, eight to a row — then exits zero itself, because a tag without a picture is not a broken site.

And the drawing goes into the page. The middling one is a shade over 250 bytes of markup, written out again for every badge that wears it: no request for it, and no way to have it once. The whole set comes to about fifteen kilobytes, and none of it reaches the site — only the drawings actually used.

Most of the drawings in that file are this project's own. Several are the shape any icon set converges on for an obvious thing — the pen, the spanner, the speech bubble on a chat post — and those are the same paths as Feather Icons, MIT licensed, copyright Cole Bemis. NOTICE says so and carries the licence, which is what a repository owes the people it borrowed from.

Until this release the honest answer was: in a paragraph, like any other link. The card such a post opens with existed as a block -- the importers make them, out of Tumblr and out of Bluesky -- but nothing anybody could type produced one. The writer that turns a post back into markdown had no syntax for it, so edit on a link post offered to drop the card, and add <file> could not make one at all. This project's own release posts stopped being link posts after 1.3 for that reason. The tool had changed; the intent had not.

Three lines in the header

---
tags: release
link: https://example.org/somebody-elses-article
link_title: The article by somebody else
link_description: What its own page says it is about.
---

Two things in this are wrong and one is worth stealing.

link: is the address the post is about. link_title: and link_description: are the words on the card. The card is drawn above the text rather than inside it: in the saved post it is the first block, ahead of the first sentence you wrote, and on the page it comes out as the paragraph before yours.

It is a header key rather than a line in the body because the card belongs to the post and not to a paragraph of it -- and because a paragraph that is only a link already means something else.

What the post is then called

A post with no title: of its own is named by the card. The heading becomes the card's title, and that heading is a link: it goes where the card goes, on the post's own page and in every listing. In a listing the date badge beside it is the way to the post itself. Below it the card does not say the same thing twice: the title has been lifted, so what is left is the description.

Two things stay yours. The post's address is still cut from your own opening words, not from the borrowed title. And the announcement, when the post goes out, carries the post's address rather than the other page's.

The type is derived, so nothing has to say type: link: a post that is a card and the words under it is filed as a link post and turns up under the site's own listing of them.

Give the post a title: and nothing is borrowed. Your heading stands, and the card renders in full underneath it -- its title, linked, with the description under it.

A paragraph that is only a link

It stays an ordinary link in ordinary text. A bare address on its own line is turned into a link and nothing more; a markdown link alone in a paragraph is a paragraph with a link in it.

That is a refusal, not an omission. If a lone link became a card, the two would be indistinguishable, and there would be no way left to write the first one -- the sentence that points at something on the way past.

What a card's address may be

A whole http:// or https:// address, or one rooted at this site -- /posts/2026/some-post/ -- for a card about another post here. The second shape is not a convenience. check --repair writes it when it straightens a relative link left behind by an import, and a value the engine writes has to be a value it reads back.

Everything else is refused before anything is written: a bare filename, a scheme that runs, and the two spellings that read as this site and resolve elsewhere, //host/path and /\host/path. A card is the one link on a post that may carry no words of its own to be judged by. link_title: with no link: behind it is refused too, rather than guessed at -- words about a card with no card.

check verifies a card rooted at this site against the archive: point one at a post that is not there and it says so by name and leaves non-zero. An address out on the web is only reached with --online.

What it costs

The card is header text, which means a desk: add <file>, or the editor that add and edit open, whose guide lists the key. The page at /write/ has no field for it -- a post written on a phone is written without a card.

Nothing goes and reads the other page. The title and the description are the ones you type -- two lines of copying, and they are plain text: markdown inside them stays on the page as the characters you wrote.

And the card goes the way a header line goes. Take the link: line out on a save and the card leaves the post, with nothing said: the save's loss guard counts the blocks under the header, and the card is no longer one of them. A card further down a post -- one an importer left there, which markdown still cannot write -- is guarded as it always was. The one in the header is a line to put back, and no warning that it is gone.

Getting to that word meant opening the article.

That is what edit does. It reads the post out of its file, writes the whole thing back out as markdown, opens it in an editor, and parses what comes back. For a post that is paragraphs and photographs the round trip is faithful and nothing is at stake. For a post carrying something markdown has no form for, it is not.

Seven rows

props <slug> gains [e] -- on a draft, on a scheduled post and on a published one alike.

Properties of part-three -- what the post is, not what it says:

  1) series          (none)
  2) part of series  (none)
  3) tags            spring
  4) type            text (from the content)
  5) unlisted        no
  6) lead image      (the site's own)
  7) chapter list    (the site's own)

Two rows are pickers rather than prompts. The series row lists the series the site already has, each with the number of posts carrying it, and drafts count -- a series that so far exists on one unpublished post is offered too. It is a list because a series typed a second time is a second series; the last row is a field, for one the site does not have yet. check reports two names a few characters apart, but only after the parts are split between them. The type row lists the eight the engine ranks -- document, video, audio, image, chat, quote, link, text -- with the way back to letting the content decide above them, saying which type that is.

The tags row is a field, because a line of commas is how tags are written everywhere else here. Above it the screen prints up to fifteen of the site's most-used, and it reads the answer exactly as the front matter reads it: commas split, a leading hash off, brackets off, empties dropped. [release, foto] typed into that row is two tags, not two tags wearing punctuation.

What the screen is for

The same post, the same change, two ways. The post has a link card at the top and one small span inside a paragraph. The change is its tags.

edit stops before saving:

Careful, saving this would lose: 1x small span.
Really continue? Type "yes":

Anything but that word cancels the save entirely. A small span is a formatting run markdown cannot write, so the round trip hands back the words without it -- and no block changes type on the way, which is why the guard counts spans as well as blocks.

[e] changes the tags, leaves the post's content identical and asks nothing, because nothing is owed. The screen reads the file, replaces one key, writes the file back. Nothing is converted in between.

Three states, not two

unlisted is a yes or a no. The other two are not.

A post that says nothing about a lead image is not a post saying no to one. It takes layout.hero from site.yml. A post that says nothing about a chapter list takes the engine's own rule: the list appears by itself from four headings up. So those rows read yes, no, or (the site's own), and the third has to be reachable: choosing the row a third time lifts the key back out of the file rather than leaving a false behind.

What it refuses

A part number without a series. It says so instead of storing a field nothing reads. Clearing the series takes the part number with it, so a post rejoining a series later does not arrive with a position from a different one.

A number outside 1 to 9999. A 0 above all: a series has a first part and no zeroth one, and the build clamps a 0 to the front, so the screen would have printed "part 0" about a post every page of the site calls part 1. An answer it cannot use changes nothing and leaves the row showing what the post still carries.

The title, the date and the text. Those are the post rather than facts about it, and they remain the editor's business. The slug has its own key on the frame above, and on a published post so does the pin.

What it costs

A rebuild, once. Setting a series and choosing a type are two answers to one question, so the rebuild is offered when the screen is left, not after each row -- and a series or a tag is not one page, it is listings.

And it can refuse to save. The screen sits at a prompt for as long as somebody takes to answer, and the scheduled-publish cron runs every fifteen minutes. If the file changed underneath, the write is abandoned and says so, rather than putting a post the cron has just published back to a draft.

1.6 asked for that decision at the wrong end: publish at the moment of sending, before the blog has rendered anything, or see the blog's own page and then find a keyboard. 1.7 closes that, and then closes the road the answer takes back.

One file, down the same connection

The answer card for a draft now carries a Publish button. Pressing it sends one file, called publish.txt, holding the slug and nothing else -- through the same share sheet, the same two shortcuts, the same SSH connection the post itself took.

The receiver knows that shape: one file in the delivery, called that. It stores nothing. It reads the slug and runs publish <slug> --yes --json. The slug becomes an argument to a command, so it is checked as hard as a filename is -- lower-case letters, digits and dashes, no leading dash to be read as a flag, no newline in the middle to glue two lines into one word -- and anything else is refused here rather than explained by whatever it hits. A publish.txt arriving beside a markdown file is not a request; it is stored like any other file.

publish --yes --json answers as one object -- slug, path, state, url, deploy, warnings, the shape add --json prints -- and leaves with zero whatever it says, because iOS Shortcuts throws away the output of a remote command that failed. Press the button twice and the second press is answered rather than obeyed: already_published, with the address.

An answer the page goes and gets

The road back has one break in it that nothing on the server can mend. The reply travels as a URL, and a page kept on a phone's home screen runs with storage of its own: the URL opens in the browser, where the draft it is about does not exist. The draft stays on the home-screen copy, looking unsent. A phone that goes into a lift loses the same answer for a duller reason.

So the page stops waiting. Before it sends anything it picks a name for its answer -- sixteen hexadecimal characters out of the browser's random source, a fresh one for each send -- and writes it into the post as receipt:. The build then leaves a small file at /write/r/<name>.json. Here is one, whole:

{"slug":"on-the-tram","state":"draft","title":"On the tram","url":"https://example.com/draft/41a0a9b77caef98a/on-the-tram/","warnings":[]}

The page asks for that address every three seconds for five minutes, and says so if it never comes: a page that gave up in silence would be indistinguishable from a post that never arrived. Press Publish and it asks the same name again until the state says published.

The build writes it, which is what keeps it true: publishing the post rewrites the same file, the draft's preview address giving way to the public one; deleting the post stops it being generated and the sweep takes it away. An answer arriving is itself the proof that the build and the upload went through.

What is in it, and what is not

Five things: the slug, the state, the title, the address, and whatever the save had to complain about -- a picture whose size could not be read, a video that will make the reader wait. The phone is the one place with no terminal to read those in.

Nothing else, on purpose. Not the path the post has on the server. Not what the run said about the site rather than about the post -- a missing base_url, whatever the rebuild warned about -- because the file sits at a public address and its only protection is that its name is sixteen random characters. Anyone who has them can read it. The draft preview it names is the address the draft is readable at anyway.

What it still refuses to do

Anything about a post already on the blog. The page cannot open one, edit one, delete, rename, schedule, or take a published post back down. It writes one post, sends it, and offers to publish that one -- and only that one, because publishing takes the receipt this page minted. It is the 1.6 design with one step added, not a console growing on the site.

What it costs

Pressing Publish announces. It is the road publish takes at a desk -- the date settled, the post out on whatever networks the site has configured, the site rebuilt and deployed -- and there is no undo on the phone.

The five minutes run from the send, not from the reload: a page reopened an hour later does not resume asking. And on a site whose deploy is owed to the next scheduled run, the file on the server can be older than the page's patience. The page then says there is no answer yet, that the blog may still be building, and to go and look before sending again -- which is not the same sentence as "it failed", and usually it was not.

Where the page is

It runs on this site, at /write/. It is a demonstration, and it keeps nothing: what you type stays in your own browser, and sending needs a key that lives in a shortcut on the phone of whoever runs the blog. Open it, write in it, and nothing here moves.

Beside it, the other half of the same idea — changing what a post is without opening what it says: its series, its tags, its type and three flags, from a screen. Then a link card written in the front matter, about fifty drawings a tag can wear, a video repacked on the way in so the reader does not wait for the whole file, and seventeen fixes.

#blogsh #ruby #staticsite

The build stopped rebuilding what nobody changed: a rebuild that changes nothing costs a seventh of what it did, an ordinary publish about two fifths. A post can be handed over as a file — by a script, a cron job, or the new page at /write/ on the blog itself, which sends from a phone over the SSH the server already has. Nothing new listens on the network.

Around those: a row of share controls under a post, an icon a tag can carry, a way out of the trash and the versions, and a photograph stored once instead of twice.

#blogsh #ruby #staticsite

A post that never had a title used to be called by its address — on this project's own reference archive that was 62 % of it. Now it is called by its own opening words, everywhere except its heading, which stays the date it has been since 1.3.

Two new pages come with it: /archive/, a map of the whole site in two levels, and /tag/, every subject it has ever written about. Both are built from the posts themselves — nothing to configure and nothing to keep up to date.

Two things a post can now decide for itself: where its teaser stops (//--more--//, asked for in issue #35), and how much of it a listing card shows — cards are cut before they are written rather than drawn in full and hidden with CSS. And a code block carries a copy button, asked for by an operator running a blog of terminal how-tos.

Underneath, four days of adversarial review: two bug bounties, 237 confirmed findings, every one closed and pinned by a test that fails on the old code — or written down with the number of posts it actually affects, which for a third of them turned out to be zero.

Full notes → CHANGELOG.md

The widest release since 1.0. Three things arrived: the commits widget reads Gitea and Forgejo — asked for by one of the first people outside this project to run the engine, because most of the Fediverse keeps its code on Codeberg, and mirroring to GitHub for one sidebar card was the workaround. widgets.commits.instance takes the server's address; that is the whole configuration. Comments work on GoToSocial — found on arch-linux.cz, where no post had ever shown a single comment, silently; my own tests had Mastodon on both ends, so they could never have caught it. And the engine now speaks the site's language everywhere: a Czech or German site used to watch its own deploy and build warnings go by in English, one line above a translated sentence. Sixty-odd sentences moved into the locales.

Under those sits the real work of this release: four adversarial audit rounds over real archives, the last one aimed at the fixes themselves — which is how it caught three of my own regressions before anyone else could. What came out of it is a principle more than a list: nothing fails silently. check refuses everything the build refuses. A crash mid-way through a queue move cannot cost a post. An install in a folder called blog [1] builds the site instead of silently publishing an empty one. An imported javascript: link becomes a dead anchor. A deploy pointed at a new server uploads everything instead of trusting the old server's records.

Nothing to migrate — git pull, rebuild, deploy. Expect a modest one: on my own 4400-post archive, eighteen files change — the stylesheet, two scripts, and one line in each draft preview whose tags have no listing page yet. Published posts do not move by a byte.

Full notes → release

A GoToSocial release, and both fixes came from the first site to wire blog.sh to a GoToSocial instance: arch-linux.cz runs its own, instead of pointing at a Mastodon account. My own tests had Mastodon on both ends, so they could never have found either.

GTS speaks Mastodon's API with its own accents, and two places in the engine had taken the Mastodon dialect for the whole language: the feed widget asked every host for JSON first and got exactly that, a JSON Feed the XML parser then reported as malformed; and doctor refused the account id its own setup had pointed you at, because it demanded digits where GTS answers with a 26-character ULID.

One small thing for skins came from the same site: a listing page now says whether it is the first one. <body> carries page-first or page-cont, so a stylesheet can tell the front of a listing from its /page/N/ continuations — something CSS cannot work out on its own, because it cannot read an address.

Nothing to migrate — git pull, rebuild, deploy. Expect one full-sized deploy: every listing page changes by those few bytes, and nothing else moves. Full notes →

A bug-fix release about restraint. The scheduled-publish cron now declines the announcements it cannot take back: a backdated post publishes without announcing, and a post that already carries its announcement address is never announced again — not by the cron, not by publish, not by toot, whichever network the address lives on. The queue takes its lock for every write too, so a tick landing mid-edit cannot revert a post it just published.

The first hour of a fresh install stopped misleading: preview and publish print the address that actually opens instead of example.com, the deploy speaks the site's language, and the example config no longer chooses Mastodon for you — a network is a choice.

And emptiness is an answer now, in both directions: an emptied section takes its heading with it instead of crashing the build or failing doctor, and a heading over content that stays can finally be turned off.

Nothing to migrate — git pull, rebuild, deploy. Full notes →

Dressing a site no longer means editing the engine: your own stylesheet, menu, sidebar and lead images are settings now. Posts group into series, pages step out of the stream, and every edit keeps the version before it.

And three commands that read the whole archive: check reports what's broken, stats counts what's there, and export packs it all into Jekyll's layout. The way out ships with it.

#blogsh #ruby #staticsite

A phone records where you were standing in every photo it takes. Social networks strip that on upload; a static site has nobody to do it. Now the engine does, on the way into the archive — and the doctor will clean the ones you saved before.

The bio, the footer, and the banner's claim are now Markdown. They were the only texts on a Markdown blog that had to be HTML.

Eight import sources became twenty-two: every social network you are likely to have posted to, the blog platforms, and the Wayback Machine for blogs whose platform no longer exists.

Setting a site up is a conversation now. So is how it looks, with the candidate palette rendered on your own site before you keep it.

And a screen for walking an archive that got too big to scroll.

Pin a post to the top. Schedule into publishing slots that queue instead of colliding. Attach files as download cards. Rename a slug without breaking a link — the old URL redirects forever. One dialogue for everything you can do to a post.

And deploy guards that measure the build against the build, so a failed upload can't quietly switch them off.

They came out of an independent verification pass over the release: a failed write could leave a post without a file, one bad post could stop the whole build, a missing media file could delete the copy that was already live.

There's now a CHANGELOG a clone can read, and ./blog.sh version tells you what you're running.

A blog engine that's a folder and a shell script. Ruby stdlib and bash — no database, no gems, no admin. Comments live on the Fediverse. Eight importers, so your Tumblr and Twitter archives have somewhere to go. MIT licensed.

The site you're reading is the engine running itself.