TinyKiss

TinyKiss is recorded as a scripting language of the amateur radio and packet networking world, dated no more precisely than the 1990s and long dormant. That sentence contains nearly everything that can be said about it with confidence, and this page is honest about why: no trace of the language has survived in any archive that could be reached. No specification, no implementation, no manual, no README, no shareware archive, no newsletter mention, and no named author or callsign could be located in the web searches, archive queries, and catalogue lookups conducted for this article on 9 September 2026.

Most entries in this encyclopedia reconstruct a language from its surviving artifacts. This one documents the rarer and more instructive situation of a language known only from its catalogue record, and treats the gap itself as the subject: what the record says, what the name and classification suggest and how far those inferences can honestly be pushed, what the packet-radio software world of the 1990s actually looked like, which better-documented things named “KISS” it must not be confused with, and what a disappearance this total says about how hobbyist software history gets lost.

What the record says

The catalogue entry that preserves the name records five fields:

That is the entire documented corpus. Every one of those values should be read with the caveat that none has been confirmed against a primary source, because no primary source could be found in any archive searched. The date in particular is unusually weak evidence: it is not a year but a decade, which is what a cataloguer writes when the underlying source did not carry a date either. Catalogue entries for obscure languages are frequently inherited from earlier lists rather than from artifacts, and a name that has been copied from list to list can outlive every copy of the thing it named - or, occasionally, can turn out never to have named a language at all.

What the classification suggests

Three things can be inferred from the record. All three are labelled here as inference, not fact, and none of them should be read as a claim about what TinyKiss was.

“KISS” plus “Radio/Packet” points at one specific protocol. In amateur radio, KISS is not a generic word. It is the host-to-TNC protocol described by Mike Chepponis (K3MC) and Phil Karn (KA9Q) at the ARRL 6th Computer Networking Conference in 1987, whose acronym stands for “Keep It Simple, Stupid”. Before KISS, a terminal node controller - the modem-and-microcontroller box that sat between a computer’s serial port and a radio - ran the whole AX.25 protocol stack itself in firmware and presented the operator with a command interface. KISS turned the TNC into a dumb frame pump: the host escapes and frames raw data with four special bytes (FEND 0xC0, FESC 0xDB, TFEND 0xDC, TFESC 0xDD), and everything above the modem - the AX.25 state machine, routing, TCP/IP - runs in software on the computer. Karn’s own KA9Q NOS was the program that made this practical, and an entire generation of host-side packet software followed. Any 1990s program named “TinyKiss” was, on the balance of naming conventions alone, almost certainly a small KISS-mode implementation of some kind: a driver, a host stack, a TNC emulator, or a utility that spoke KISS framing to a radio.

“Tiny” is a claim about size, and in this era it was a genre. The prefix has a long and consistent history in computing: Tiny BASIC in the mid-1970s, written to fit interpreters into a few kilobytes of a hobbyist microcomputer; the tiny-c lineage; and, in the online-world software that sits immediately beside this entry in the same catalogue, the whole TinyMUD family - TinyMUD itself, then TinyMUCK, written by Stephen White in the winter of 1990 from the TinyMUD 1.5.2 codebase and given the MUF programming language by Piaw Na in the TinyMUCK 2.0 release of June 1990, along with client-side descendants such as TinyFugue. In every case “Tiny” advertises a deliberately minimal reimplementation of something larger. A program called TinyKiss is announcing that it is a small KISS something, most likely defined against a bigger and better-known implementation whose name would tell us far more - if we knew it.

A “scripting language” here would most plausibly be an automation layer, not a general-purpose language. Packet radio in the 1990s was full of tasks that begged to be scripted: connecting through a chain of digipeaters and network nodes, logging into a BBS, running an unattended mail forwarding session at a scheduled hour, answering beacons, and driving a station without an operator present over a link far too slow and lossy to babysit. Host programs of the period accordingly grew macro facilities, command files, and small interpreters. If TinyKiss carried a scripting language, the overwhelmingly likely shape of it is a line-oriented command language for driving a KISS-mode link - send this, wait for that, retry, log - rather than anything a general-purpose programmer would recognize as a language. That is a guess from genre, and it is offered here only to bound the space, not to fill it.

Not to be confused with

The name is the reason this entry is nearly unrecoverable. Every component of it is a word that something more famous already owns, and searching for it returns those things instead. All of the following are well documented, and none of them is a 1990s packet-radio scripting language:

The world TinyKiss would have appeared into

Nothing further can be said about the language, but the niche the record places it in is well documented, and it makes the existence of such a program entirely plausible.

Amateur packet radio was built on AX.25, the link-layer protocol adapted from X.25 and published by the ARRL in Terry Fox’s version 2.0 specification in 1984. Stations used call signs as addresses, chained frames through digipeaters, and ran at 1200 baud on VHF - a rate that made every byte count and every automated retry worth writing. Hardware TNCs, most of them descended from the TAPR TNC-2 design, ran the stack in firmware. The 1987 KISS protocol changed the shape of the hobby by moving that stack onto the host, and the software that resulted defined the decade that followed: Phil Karn’s KA9Q NOS and its many derivatives brought a full TCP/IP stack, driven by command files, to the amateur bands; BBS packages such as Jean-Paul Roubelat’s FBB, created in 1986 and maintained ever since, ran the store-and-forward mail network that carried amateur traffic worldwide; and Bob Bruninga’s APRS, developed from the late 1980s onward and reaching recognizably its current form in the early 1990s, turned packet into a real-time position and telemetry system.

This was a shareware culture. Its software was written by individuals, identified by callsign as often as by name, and distributed on floppy disks at club meetings, on dial-up bulletin boards, on the hamradio directories of FTP archives, and on CD-ROM compilations. Documentation was a README.TXT in a ZIP file. Very little of it was ever indexed by a search engine, because most of it stopped circulating before the web became the medium of record - and when the archives that held it were retired, whole categories of small utility vanished at once. A minimal KISS tool with a scripting facility, written by one operator in the middle of that decade and distributed on those channels, is exactly the sort of artifact that would leave a name in a list and nothing else behind.

Two further pressures worked against preservation specifically here. The hobby’s own centre of gravity moved: as the Internet became universally available in the late 1990s, connected-mode packet BBS traffic collapsed, and the survivors of the software ecosystem were the projects with maintainers, not the single-author utilities. And the naming convention worked against it too. Software identified by a four-letter protocol acronym, with no author’s name, no vendor and no distinctive term anywhere in the title, is effectively unsearchable once its own community stops linking to it.

What could not be verified

In the interest of transparency - and so that an editor with better sources can pick up where this page leaves off - here is what was searched, on 9 September 2026, without result:

• General web search, under “TinyKiss” and “Tiny KISS” combined with programming language, scripting language, packet radio, TNC, ham, amateur radio, and Kisekae; every result concerned one of the unrelated things listed in the collision table above
• The Internet Archive, both its catalogue search and its Wayback CDX index, which finds no archived page, file, or directory listing under the name anywhere except the unrelated tinykiss.com domain
• GitHub, whose repository search returns zero results for the name
• The 99 Bottles of Beer language catalogue, the source of a surprising number of obscure names in this encyclopedia, which has no language page for TinyKiss in any Wayback capture
• The Esolang wiki, PLDB (whose full concept list contains kiss but nothing resembling TinyKiss), and Rosetta Code, none of which record it
• The online HOPL encyclopedia, whose by-name and string-match searches returned no language of this name, with the caveat that its backing database timed out on several queries during the session
• Google Books, which could not be queried because the API’s daily quota was exhausted, and Usenet archives, which were behind bot challenges - the two sources most likely to hold a 1990s shareware mention, and therefore the two most worth retrying

No match was found in any source that could be reached. Accordingly, this page asserts no author, no callsign, no host platform, no feature list, no syntax, no implementation status, and no influence relationships. If the language survives anywhere, it is most likely inside an unindexed shareware ZIP file on a CD-ROM compilation, in the pages of a club newsletter that was never digitized, or in the memory of an operator who ran it.

Why it matters

It may seem odd for an encyclopedia to keep an entry it cannot substantiate. There are two reasons this one stays.

Hobbyist software is the most fragile kind of software history. Commercial languages leave manuals, trademarks, lawsuits, job advertisements and disgruntled maintenance programmers. Academic languages leave papers with DOIs. Amateur radio software of the 1990s left a ZIP file that circulated for a few years among a few thousand operators and then stopped. That community built, entirely without funding, a worldwide store-and-forward digital network that predated widespread Internet access - and the record of how it did so is now scattered across dead FTP mirrors, defunct BBSes and paper newsletters. TinyKiss is one datapoint in that loss, and an honest empty entry records it more accurately than a confabulated full one would.

A name can erase a history. This site’s entries for Julie4Chapel and LOCK document the same phenomenon from the other two directions: a name so rare that nothing links to it, and a name so common that the concept drowns the language. TinyKiss is the third variety - a name assembled entirely out of other people’s words, where a protocol, a slogan, a paper-doll format and two esoteric languages each return thousands of results before the thing you are looking for returns one. Preserving software is not only about keeping the artifacts. It is also about keeping the metadata that lets someone find them again, and a name with no author, no expansion and no distinctive term attached is metadata that has already failed.

If you have primary information about this language - a disk, an archive, a manual page, a newsletter clipping, or a memory of running it on a TNC in the 1990s - it would be genuinely welcome. A single surviving artifact would let this page be rewritten into a real history.