.TH pidgin 7
.SH NAME
pidgin \- Pidgin Markup For Writing, or How Much Can HTML Sustain?
.SH AUTHOR
Artyom Bologov
.SH SYNOPSIS
HTML is flexible and was shaped by generations of web practitioners. It has enough tricks up its sleeve to actually be nice to author. Here are some.
.SH TEXT


.P
\fBhypertext (7)\fP
I am an HTML extremist.
There’s this argument I often hear: “But HTML is cumbersome to write!”
\fBfalsehoods-html (7)\fP
Wrong, as many other myths about HTML.
In this post, I’m detailing how I write my dialect of HTML and why it’s easy.

.P
This Pidgin HTML dialect is intimately tied to my website setup:
\fBthis-post-is-ed (7)\fP
I’m using ed(1) as my Static Site Generator.
Which means the setup is:

.P
* I write my Pidgin HTML in \fB.htm\fP files.
    It’s a standard HTML extension, but it’s useful to differentiate from the resulting \fB.html\fP for build purposes.
.P
* I preprocess SSI-like comments and include files.
.P
* I convert overly smart and (slightly) weird tags into valid HTML.
.P
* And then I send the result to
  \fBcodeberg-pages (7)\fP
Another Person’s Computer™
  for you to see on aartaka.me.

.P
This setup is no rocket science, doing sloppy tags, regex substitutions, and shell scripts.
And yet it results in a dialect of HTML that’s easy/er to write.
And almost standard/conventional.
Here’s a set of engines I’m testing my markup with:

.P
*  
.UR https://dillo.org
Dillo
.UE
.P
* 
.UR https://w3m.sourceforge.net
w3m
.UE
.P
* Firefox/LibreWolf
.P
* (Ungoogled) Chromium
.P
* WebKitGTK browser engine
.P
* 
.UR https://github.com/Shinmera/plump
Plump
.UE
, an HTML parser for Lisp.

.P
So yeah, it does work everywhere, even as the raw source form.

.P
You can see the initial Pidgin HTML for this post rendered at

.UR pidgin.htm
pidgin.htm
.UE
, and

.UR pidgin.htm download
download it to preview the text behind it
.UE
.

.UR https://developer.mozilla.org/en-US/docs/Web/HTML/Guides/Quirks_mode_and_standards_mode
On to the quirks then
.UE
!

.SH Smart tags

.P

.UR https://merveilles.town/@aartaka/115669971371343412
HTML links are slightly painful to type out
.UE
.
So I made my own syntax, knowing that my build regex will expand it for me:

.P
.in +4n
.EX
<a \fBjust (7)\fP
just.htm>local link to other post</a>
<a //something.com>
.UR https://url.spec.whatwg.org/#scheme-relative-special-url-string
Scheme-relative link
.UE
</a>
<a 
.UR https://aartaka.me
aartaka.me
.UE
>Arbitrary link without https:// formalities</a>
.EE
.in
.P
— Simplified links

.P
There’s a bunch of other tags, like \fB<c>word\fP for simpler \fBcode\fP tags.
And shorter \fB<img assets/pidgin.png Image of a silly pigeon drawing...>\fP.
Not much, but more than enough for comfortable writing.
Now to the more grand things.

.SH Implied End Tags

.P
I think this is the heritage of sloppy HTML 1/2/3 programming.
You know, with shortcuts following authors’ practice.
The primordial chaos reigning in the early Internet.

.P
Long story short, you don’t have to close \fB<p>\fP.
Its end tag is implied and closed whenever e.g. the next opening \fB<p>\fParagraph tag is encountered.

.UR https://html.spec.whatwg.org/#closing-elements-that-have-implied-end-tags
Spec: li, dt, dd, td, and some others also work this way
.UE
.
This is valid processable HTML:

.P
.in +4n
.EX
<p>
hello

<p>
another hello

<ul> one
<li> two
<li> wait, it’s not an ordered list?
</ul>
.EE
.in
.P
— Implied end tags in action

.B this ul...
.EX
.P
You may’ve noticed the \fB<ul>\fP followed by text.
This is another of my shortcuts.
It looks alright (indented) when opened from source \fB.htm\fP file.
It’s easy to type.
And it’s a simple substitution away from a valid \fB<ul> <li>\fP list.
.EE

.P
Having these, I can generate sensible HTML with ed(1) scripts.
While having the convenience of shortcuts in standard HTML.
All according to the spec!

.SH Closing Tag Space

.P
Here’s a fun one: HTML spec forbids putting anything into closing tags (anything after \fB</tag\fP).
Yet… everyone parses it just fine.
So I can e.g. put things into the epilogue of a \fBpre\fP tag as a caption for the code block:

.P
.in +4n
.EX
<pre html>
<!-- ... -->
</pre Example of closing tag captions>
.EE
.in
.P
— Example of closing tag captions

.P
I mean, it’s not a caption per se.
And it renders as plain \fB<pre>\fP when previewed in \fB.htm\fP source.
But once I process it with my build scripts, it expands to a proper \fB<figcaption>\fP.
Without the need to write all the formalities out myself.

.SS Arbitrary Attributes

.P
A thing partially related to closing tag contents: HTML allows anything as attributes.
This previous sentence might work well as an attribute set:

.P
.in +4n
.EX
<span HTML allows anything as attributes>...</span>
<!-- turns into -->
<span HTML="" allows="" anything="" as="" attributes="">...</span>
.EE
.in
.P
— Anything you put into tags is attribute, actually

.P
I’m using that for e.g. tables and \fB<details>\fP:


.P
.in +4n
.EX
<details this ul...>
You may’ve noticed the ...
</details>
.EE
.in
.P
— Efficient leading tag space use

.P
And I’m using \fB<h2 id>\fP as a shortcut for headings with IDs (\fB<h2 id=id>\fP).

.SH Magic IE Comments and Server Side Includes


.P
In case you ever opened the inspector

.UR https://mozilla.org
on some major site
.UE
,
you might’ve seen these \fB[if IE]\fP comments.
Basically Internet Explorer specific comments that only IE evaluates.
Other browsers perceive them as mere comments.

.P
.in +4n
.EX
<!--[if IE 9]>
    <script src="https://www.mozilla.org/media/js/lib-ie.cf16e08599c3.js"></script>
<![endif]-->
.EE
.in
.P
— Example IE conditional comment from mozilla.org

.P
These are useless in the modern post-IE world.
That’s why I’m exploiting them to generate format-specific content.
Say, making a link footer when generating Gemtext from this Pidgin HTML:
(I've since removed Gemtext backend from this site, unfortunately. Gemtext is too primitive.)

.P
.in +4n
.EX
<!--[if GMI]>
=> index.gmi Back to home page
=> about.gmi About & Contacts
=> uses.gmi Tech I Use
=> projects.gmi My projects
&lt![endif]-->
.EE
.in
.P
— GMI-specific content via IE comment

.P
Another point of reference might be

.UR https://wikipedia.org/wiki/Server_Side_Includes
Server Side Includes
.UE
.
Initially Apache-specific format of commands embedded into HTML (or, rather .shtml) pages.
Allowing file inclusion, conditional expansion, shell/CGI command execution etc.
A much needed logic-ful HTML extension.

.P
So I’m using SSI as an inspiration, making my own \fB#include\fP and \fB#exec\fP directives.

.P
.in +4n
.EX
<include template/footer>
as a shorthand for
<!--#include file="template/footer" -->
.EE
.in
.P
— SSI-like inclusion command

.P
This is recognized as a mere starting tag.
Or, in case of the SSI version, as a comment.
Harmless.

.SH Pidgin HTML is Still HTML

.P
Let this post be a praise to

.P
* shortcuts of HTML,
.P
* its simple user-facing nature,
.P
* and the universality and power of Web Platform.

.P
Pidgin HTML is made possible by sloppiness of the standard/quirks HTML.
It’s still valid HTML, but one that is much easier to write.
Good for authoring as a hypertext alternative to Markdown.
And other Lightweight Markup Languages.

.P
Don’t be afraid of HTML.
Write Pidgin HTML.


.SH COPYRIGHT

.UR https://creativecommons.org/licenses/by/4.0
CC-BY 4.0
.UE
 2022-2026 by Artyom Bologov (aartaka,)

.UR https://codeberg.org/aartaka/pages/commit/a91befa
with one commit remixing Claude-generated code
.UE
.
Any and all opinions listed here are my own and not representative of my employers; future, past and present.