Kermit

Kermit is best remembered as a file-transfer protocol - perhaps the most widely ported piece of communications software ever written - but living inside the Kermit programs is something the encyclopedia of programming languages should not overlook: a full procedural scripting language. What began in 1981 as a friendly, TOPS-20-style interactive command interface for the Kermit file-transfer programs from Columbia University grew, over the following decade and a half, into a genuine programming language with variables, macros, loops, arrays, associative arrays, recursion, pattern matching, file I/O, and an expect-style dialog automation system that predates expect itself. For a generation of system administrators, laboratory engineers, and bulletin-board operators, “writing a Kermit script” was how you automated anything that happened over a serial port or a modem.

The story has a remarkable coda. After the last stable release in 2011, the language spent 15 years dormant - until August 3, 2026, when the Open Kermit project shipped C-Kermit 11.0.506, the first stable release since Columbia’s era, in the software’s 45th anniversary year.

History and origins

In 1980-81, Columbia University’s computer center faced a mundane but universal problem: students and staff needed to move files between the university’s DECSYSTEM-20 and IBM mainframes and the first wave of microcomputers, across machines that disagreed about character sets, file systems, line speeds, and even how many bits made a byte. Frank da Cruz and Bill Catchings designed a protocol robust enough to survive all of it. Catchings wrote the first two implementations - one for the DEC-20, one for a CP/M-80 micro - and the first Kermit file transfer took place in April 1981 between two DECSYSTEM-20s joined by a null-modem cable. The name came from Kermit the Frog, used with permission from Henson Associates.

Columbia gave the software away, published the protocol specification in BYTE magazine in 1984, and formally founded the Kermit Project in 1986. By 1988 Kermit ran on more than 300 computers and operating systems, which is a strong candidate for the widest platform coverage of any software of its era.

The language grew out of the user interface. Kermit’s interactive command style - full-word commands, ? help at any point, abbreviation, keyword completion - was adapted from the TOPS-20 EXEC, the beloved command interface of the DECSYSTEM-20 that had been Columbia’s academic machine from 1977 to 1988. Command files and simple macros came early; then, beginning with C-Kermit 5A(190) and MS-DOS Kermit in the mid-1990s, the project added real programming constructs. The Kermit Project’s documentation cites ALGOL 60, C, BLISS-10, PL/I, SNOBOL, and Lisp as syntactic and semantic influences on what the command language became: a general-purpose scripting language whose specialty happened to be talking to other computers.

Design philosophy

Kermit the protocol was built on a pessimistic assumption - the connection is bad, the other computer is strange, and anything that can be corrupted will be - and the language inherited the matching optimistic mission: a person who is not a programmer should be able to automate a communication session anyway.

• Commands read like English. set modem type usrobotics, dial 7654321, if failure hangup. The interactive language and the programming language are the same language; a script is just the commands you would have typed, and anything you can do in a script you can rehearse by hand at the prompt.

• The hard part is built in. Where a general-purpose language needs libraries and glue to open a serial port, negotiate a modem, or checksum a transfer, in Kermit those are primitives. The script language sits above a complete communications stack - serial, modem, Telnet, and later FTP, HTTP, and SSH - with file transfer as a single command.

• Dialogs are programmable. The INPUT command waits (with a timeout) for a pattern to arrive from the remote system; OUTPUT sends text in reply. This send/expect model - the heart of every login automation - was in Kermit before the famous Unix expect tool popularized the idea, and the Open Kermit project today describes C-Kermit as “the shell, but with built-in screen-scraping automation like expect and built-in file transfer.”

• Fail safely and loudly. Every command sets success or failure status, and IF FAIL, SET TAKE ERROR, and friends make scripts that cope with the real world of dropped carriers and garbled prompts.

Key features

A command language that became a programming language

Kermit scripts use \%a-\%z style user variables, \v(name) built-in variables (date, time, connection state, and dozens more), and \fname(args) built-in functions for string manipulation, arithmetic, and file handling. Macros defined with DEFINE take arguments and can call themselves recursively. Control flow includes IF/ELSE, SWITCH, FOR, WHILE, GOTO with labels, and block structure with braces. Later versions added arrays, associative arrays, list processing, and pattern matching - a feature set the project itself summarized as having grown “into a general-purpose programming language.”

A fragment in the style of the Kermit Project’s script library shows the flavor - a login dialog with retries:

#!/usr/local/bin/kermit +
set host ts.example.edu 23          ; make the connection
if fail exit 1 Connection failed.
for \%i 1 3 1 {                     ; three attempts
    input 10 login:                 ; wait up to 10 sec for prompt
    if fail continue
    lineout \%1                     ; send username (argument 1)
    input 10 Password:
    if fail continue
    lineout \%2                     ; send password (argument 2)
    input 15 $                      ; wait for shell prompt
    if success break
}
if fail exit 1 Could not log in.
send report.txt                     ; Kermit-protocol file transfer

The first line is a “kerbang” script: on Unix, a Kermit script marked executable runs directly from the shell, just like a shell or Perl script, with the trailing + telling Kermit to pass along command-line arguments.

The protocol underneath

The language would not matter without the machinery it drives. The Kermit protocol’s packet design was engineered for the worst connections computing could offer: 7-bit-only links, half-duplex mainframe front ends, systems that reportedly had trouble accepting more than 96 bytes at a time, and networks that swallowed control characters. Character-set translation - including EBCDIC/ASCII conversion and, from the early 1990s, multilingual character encodings - was built into the transfer itself, a concern most rival protocols simply ignored.

One language, many Kermits

The same command language (with local variations) appeared across the major implementations: C-Kermit for Unix, VMS, and many other systems; MS-DOS Kermit, maintained by Joe R. Doupnik at Utah State University, one of the most widely used DOS communication programs of its day; and Kermit 95, the commercial Windows and OS/2 version led by Jeffrey Altman from 1995. Smaller relatives - G-Kermit, a minimal GPL Unix file-transfer program, and E-Kermit, a protocol module for embedding in devices - carried the protocol without the full language.

Evolution

The language’s growth tracks the C-Kermit releases: 5A(188) in November 1992 unified the ports and was the version documented in the first edition of Using C-Kermit by da Cruz and Christine M. Gianone; the 5A(189)-(190) releases of the mid-1990s brought the programming constructs; 6.0 (September 1996) and 7.0 (2000) deepened the function library and pattern matching; 8.0 (December 2001) added built-in FTP and HTTP clients that made Kermit scripts capable of driving internet protocols directly.

Then came the long quiet. Columbia University ended its 30-year sponsorship of the Kermit Project in 2011; C-Kermit 9.0 arrived on June 30, 2011 under the Revised 3-Clause BSD License, converting a formerly restrictively-licensed program into genuine open source on its way out the door. Frank da Cruz kept the project alive independently for another decade and a half - C-Kermit 10.0 circulated as betas into 2025 - before retiring from active development in 2025, after 44 consecutive years at the helm, a tenure with few if any equals among open-source founders.

The revival came from outside Columbia entirely. John Goerzen’s Open Kermit project took up stewardship, added C unit tests and a Python regression suite to the decades-old codebase, and on August 3, 2026 released C-Kermit 11.0.506 - the first stable release in 15 years, with IPv6 support, compatibility with modern OpenSSL, security fixes, and a dedication to da Cruz.

Current relevance

Kermit today is a niche tool with an unusually loyal niche. Serial consoles never went away: network gear, embedded boards, industrial controllers, and retrocomputers all still speak RS-232, and a scripting language with a communications stack built in remains the right shape for that work. The Kermit Project has reported its software embedded in routers, cell-phone towers, medical equipment, and point-of-sale systems, flying on the International Space Station from late 2002, and riding autonomous EM-APEX ocean floats that feed data to hurricane researchers. The 2026 revival gives the language something few of its 1981 contemporaries have: an active maintainer, a test suite, and a fresh stable release.

Why it matters

Kermit’s scripting language earns its encyclopedia entry on three grounds. First, longevity: a language lineage running continuously from 1981 to a stable release in 2026, under its founder’s care for 44 of those years, is nearly unique in software history. Second, the design insight that the interactive interface and the automation language should be the same thing - learned from the TOPS-20 EXEC and carried forward into an era that mostly forgot it - along with send/expect dialog automation that anticipated expect. Third, reach: as the scripting face of software ported to hundreds of platforms and used everywhere from campus terminal rooms to the International Space Station, the Kermit language quietly automated more real-world communication sessions than almost any tool of its era.

For the code archaeologist, Kermit is a living dig site: the full source is on GitHub under a BSD license, the script library and books are preserved at the Kermit Project and Open Kermit sites, and - rarest of all for a language born in 1981 - the current release is dated this month.