Hubbry Logo
Kermit (protocol)Kermit (protocol)Main
Open search
Kermit (protocol)
Community hub
Kermit (protocol)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Kermit (protocol)
Kermit (protocol)
Kermit (protocol)
View on Wikipedia
from Wikipedia

Kermit
Communication protocol
PurposeFile transfer
Developer(s)Columbia University
Introduction1981; 44 years ago (1981)
Websitewww.kermitproject.org

Kermit is a computer file transfer and management protocol and a set of communications software tools primarily used in the early years of personal computing in the 1980s. It provides a consistent approach to file transfer, terminal emulation, script programming, and character set conversion across many different computer hardware and operating system platforms.

Technical

[edit]

The Kermit protocol supports text and binary file transfers on both full-duplex and half-duplex 8-bit and 7-bit serial connections in a system- and medium-independent fashion, and is implemented on hundreds of different computer and operating system platforms. On full-duplex connections, a sliding window protocol is used with selective retransmission which provides excellent performance and error recovery characteristics. On 7-bit connections, locking shifts provide efficient transfer of 8-bit data. When properly implemented, as in the Columbia University Kermit Software collection, its authors claim performance is equal to or better than other protocols such as ZMODEM, YMODEM, and XMODEM, especially on poor connections.[1] On connections over RS-232 Statistical Multiplexers where some control characters cannot be transmitted,[citation needed] Kermit can be configured to work, unlike protocols like XMODEM that require the connection to be transparent (i.e. all 256 possible values of a byte to be transferable).

Kermit can be used as a means to bootstrap other software, even itself. To distribute Kermit through non 8-bit clean networks Columbia developed .boo, a binary-to-text encoding system similar to BinHex. For instance, IBM PC compatibles and Apple computers with a Compatibility Card installed can connect to otherwise incompatible systems such as a mainframe computer to receive MS-DOS Kermit in .boo format. Users can then type in a "baby Kermit" in BASIC on their personal computers that downloads Kermit and converts it into binary.[2][3]

Similarly, CP/M machines use many different floppy disk formats, which means that one machine often cannot read disks from another CP/M machine, and Kermit is used as part of a process to transfer applications and data between CP/M machines and other machines with different operating systems. The CP/M file-copy program PIP can usually access a computer's serial (RS-232) port, and if configured to use a very low baud rate (because it has no built-in error correction) can be used to transfer a small, simple version of Kermit from one machine to another over a null modem cable, or failing that, a very simple version of the Kermit protocol can be hand coded in binary in less than 2K using DDT, the CP/M Dynamic Debugging Tool. Once done, the simple version of Kermit can be used to download a fully functional version. That version can then be used to transfer any CP/M application or data.[4]

Newer versions of Kermit included scripting language and automation of commands.[5] The Kermit scripting language evolved from its TOPS-20 EXEC-inspired command language[6] and was influenced syntactically and semantically by ALGOL 60, C, BLISS-10, PL/I, SNOBOL, and LISP.[7]

The correctness of the Kermit protocol has been verified with formal methods.[8]

History

[edit]

In the late 1970s, users of Columbia University's mainframe computers had only 35 kilobytes of storage per person. Kermit was developed at the university so students could move files between them and floppy disks at various microcomputers around campus,[9][10][11] such as IBM or DEC DECSYSTEM-20 mainframes and Intertec Superbrains running CP/M. IBM mainframes used an EBCDIC character set and CP/M and DEC machines used ASCII, so conversion between the two character sets was one of the early functions built into Kermit. The first file transfer with Kermit occurred in April 1981. The protocol was originally designed in 1981 by Frank da Cruz and Bill Catchings.[12][13]

Columbia University coordinated development of versions of Kermit for many different computers at the university and elsewhere, and distributed the software for free; Kermit for the new IBM Personal Computer became especially popular. In 1986 the university founded the Kermit Project, which took over development and started charging fees for commercial use; the project was financially self-sufficient.[11] For non-commercial use, Columbia University stated that[14]

Kermit is for everyone to use and share. Once you get it, feel free to pass it along to your friends and colleagues. Although it is copyrighted and not in the public domain, we only ask that you not attempt to sell it for profit, and that you use it only for peaceful and humane purposes.

By 1988 Kermit was available on more than 300 computers and operating systems.[15] The protocol became a de facto data communications standard[16] for transferring files between dissimilar computer systems, and by the early 1990s it could convert multilingual character encodings. Kermit software has been used in many countries, for tasks ranging from simple student assignments to solving compatibility problems aboard the International Space Station.[11] It was ported to a wide variety of mainframe, minicomputer and microcomputer systems down to handhelds and electronic pocket calculators. Most versions had a user interface based on the original TOPS-20 Kermit. Later versions of some Kermit implementations also support network as well as serial connections.

Implementations that are presently supported include C-Kermit (for Unix and OpenVMS) and Kermit 95 (for versions of Microsoft Windows from Windows 95 onwards and OS/2), but other versions remain available as well.

As of 1 July 2011, Columbia University ceased to host this project and released it as open source. In June 2011, the Kermit Project released a beta version of C-Kermit v9.0 under the Revised 3-Clause BSD License.[17]

As well as the implementations developed and/or distributed by Columbia University, the Kermit protocol was implemented in a number of third-party communications software packages, among others ProComm and ProComm Plus.[18][19][20][21][22] The term "SuperKermit" was coined by third-party vendors to refer to higher speed Kermit implementations offering features such as full duplex operation,[23] sliding windows,[24][25][26][27][28][29] and long packets; however, that term was deprecated by the original Kermit team at Columbia University, who saw these as simply features of the core Kermit protocol.[30]

[edit]

Kermit was named after Kermit the Frog from The Muppets, with permission from Henson Associates.[31] The program's icon in the Apple Macintosh version was a depiction of Kermit the Frog. A backronym was created, perhaps to avoid trademark issues, KL10 Error-Free Reciprocal Microprocessor Interchange over TTY lines,[32] but the developers stopped using the backronym after obtaining permission.[33]

Kermit is an open protocol—anybody can base their own program on it, but some Kermit software and source code is copyright by Columbia University.[34][35] The final license page said:[36]

As of version 9.0 (starting with the first Beta test), C-Kermit has an Open Source license, the Revised 3-Clause BSD License. Everybody can use it as they wish for any purpose, including redistribution and resale. It may be included with any operating system where it works or can be made to work, including both free and commercial versions of Unix and Hewlett-Packard (formerly DEC) VMS (OpenVMS). Technical support will be available from Columbia University only through 30 June 2011.

See also

[edit]

References

[edit]

Further reading

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Kermit (protocol)

View on Grokipedia
from Grokipedia
Kermit is a modular and management protocol developed at Columbia University's Computer Center in 1981 to enable reliable communication between microcomputers and mainframes over serial connections and modems. Named after the Muppet character —inspired by a in a developer's office—the protocol emphasizes adaptability, error correction, and efficiency in challenging environments like noisy phone lines or low-bandwidth links. Its core mechanism involves exchanging small packets of data with built-in acknowledgments, retransmissions, and checksums to ensure error-free transfers, making it particularly suited for asynchronous communications where other protocols like XMODEM or might fail. Over its history, Kermit evolved through a cooperative international effort led by until the project's cancellation in 2011, during which it generated significant revenue and supported diverse applications, including U.S. automation, the 1994 Brazilian elections, and relief efforts in Bosnia. Key innovations include support for sliding windows to improve throughput, long packets for larger file handling, character-set translation for cross-platform compatibility, and integration with secure protocols like SSH, SSL/TLS, and Kerberos. The protocol's implementations, such as C-Kermit for systems and Kermit 95 for Windows, provided terminal emulation, scripting, and file management capabilities, before transitioning to open-source licensing in 2011. Kermit's reliability and versatility led to its adoption in specialized fields, including embedded systems for devices, automation (such as Boeing's 787 assembly), and even space missions aboard the in 2002. Unlike network-oriented protocols like FTP, Kermit excels in half-duplex or intermittent connections, maintaining high performance without requiring full-duplex channels or complex handshakes. Today, while largely superseded by TCP/IP-based alternatives in general , it remains in use for legacy systems, secure dial-up sessions, and resource-constrained environments where robustness is paramount.

Overview

Purpose and Design Goals

The Kermit protocol was developed in 1981 at Columbia University to facilitate reliable file transfers between diverse and incompatible computer systems, particularly over asynchronous serial connections such as modems and telephone lines. This initiative addressed the challenges of early personal computing, where microcomputers needed to connect to mainframes like DECSYSTEM-20s and IBM 370-series systems without dedicated networks. The protocol's creation by Bill Catchings and Frank da Cruz aimed to enable error-free data exchange in heterogeneous environments, ensuring compatibility across a wide range of hardware and software without requiring specialized networking hardware. Central to Kermit's design were objectives of achieving robust, error-free transfers while maintaining minimal implementation complexity, making it suitable for resource-constrained devices like microcomputers as well as larger mainframes. It prioritized reliability over raw speed, incorporating mechanisms like checksum-verified packets and adaptive retransmissions to handle noisy or low-bandwidth links effectively. The protocol was engineered to adapt dynamically to connection characteristics, such as half-duplex or full-duplex modes and varying rates, ensuring dependable performance in environments prone to interruptions, like dial-up connections. A key design principle was the "" approach, which emphasized broad by using printable ASCII characters and supporting both 7-bit and 8-bit systems without mandating advanced features. This lightweight structure allowed Kermit to operate efficiently on systems with limited resources, converting file formats and character sets as needed to bridge differences between sender and receiver platforms. By focusing on simplicity and universality, the protocol avoided the need for complex configurations, promoting its adoption in diverse academic and professional settings where reliability in file management was paramount.

Key Features and Advantages

Kermit's robust error detection mechanism employs checksums—available in one-, two-, or three-character formats, including CRC-CCITT—and sequence numbers modulo 64 to identify and retransmit only corrupted or missing packets, ensuring high reliability over noisy connections. This approach allows selective retransmission without requiring the entire file to be resent, a significant improvement in efficiency for unreliable links. The protocol supports both binary and text file transfers, automatically detecting the file type and performing character set conversions, such as from to ASCII for text files, while handling parity bits and line endings like CRLF delimiters to maintain across diverse systems. In binary mode, the eighth bit is preserved through optional prefixing, preventing during transmission. Kermit features a long-packet mode, supporting up to 9024 bytes for efficient transfers on reliable links, with a fallback to short-packet mode (up to 94 characters) for poor connections, allowing dynamic adjustment of packet sizes during the session based on error rates or system capabilities. Additionally, its server mode enables remote file management—such as listing directories, sending, or receiving files—without requiring full terminal emulation, facilitating automated operations over terminal connections. Compared to contemporaries like XMODEM, which lacked advanced recovery features, Kermit delivers superior performance over dial-up lines through its adaptive packet sizing and simple acknowledgment-based protocol, eliminating the need for sliding windows or complex handshaking while maintaining robustness. It also supports resuming interrupted transfers by recovering from the point of failure using end-of-file packets with discard indicators, and handles varying packet sizes dynamically to optimize throughput without session reconfiguration.

History

Origins at Columbia University

The Kermit protocol was created in April 1981 by Frank da Cruz and Bill Catchings at 's Center for Computing Activities (CUCCA), as part of efforts to facilitate reliable file transfers in a environment. Da Cruz, a staff member in the computing support team, and Catchings, a , designed the protocol to address the challenges of connecting diverse systems without relying on vendor-specific solutions. This work emerged from the broader context of Columbia's computing infrastructure, where mainframes and emerging microcomputers operated in silos, necessitating a simple, adaptable method for data exchange over dial-up telephone lines. The first successful Kermit file transfer occurred on April 29, 1981, conducted by Bill Catchings between two instances of the protocol running on a single DEC-20 mainframe connected via serial ports, marking the initial validation of the design. Shortly thereafter, in May 1981, Catchings implemented the first cross-platform versions: Kermit-20 for the DEC-20 (written in PDP-10 assembly) and an early Kermit-80 for CP/M-80 microcomputers, enabling transfers between mainframes and devices such as the TRS-80 Model III. These initial programs were straightforward implementations focused on core transfer functionality, quickly adapted to other platforms due to the protocol's emphasis on portability and minimal hardware assumptions. The development was driven by the need to interconnect isolated departmental computers—including DEC minicomputers, mainframes, and Apple microcomputers—across phone lines in an era before widespread local area networks or open standards. Without access to proprietary networks like those from DEC or , academic users required a non-commercial, easily implementable solution for tasks such as sharing files, , and documents between central facilities and personal workstations. Kermit's origins thus reflected Columbia's practical demands for in a fragmented technological landscape. Early adoption within academia was accelerated by the protocol's free distribution through Columbia's computing support channels, allowing rapid dissemination to universities and research institutions. Comprehensive , culminating in the publication of Kermit: A by Frank da Cruz, further solidified its role as a standard tool for academic , providing detailed specifications and implementation guidance that encouraged ports to dozens of systems by the mid-1980s.

Evolution and Major Versions

Following its initial deployment in for file transfers between a DEC-20 mainframe and microcomputers at , the Kermit protocol experienced rapid expansion throughout the 1980s. By , implementations had been ported to over 200 different computer systems and operating environments, facilitated by its modular design and the growing availability of distributions. This proliferation was aided by the release of C-Kermit in , a portable implementation written in C that enabled adaptations across diverse platforms without requiring extensive rewriting. Major versions marked key advancements in functionality and compatibility. The original Kermit protocol emerged in 1981, followed by MS-Kermit for in 1982, which supported early PC file transfers. In the , enhancements focused on network integration, with C-Kermit 5A (1992) introducing TCP/IP support and scripting capabilities, and C-Kermit 6.0 (1996) adding automated upload/download features over TCP connections. Later releases like C-Kermit 8.0 (2001) and Kermit 95 (1995) for Windows further expanded accessibility with graphical interfaces and broader protocol refinements. Standardization efforts culminated in RFC 2839 (2000), which defined the Kermit Service (IKS) for secure, server-based file transfers over , though it saw limited adoption due to competing protocols. Subsequent versions integrated modern security, including SSH and SSL/TLS support in C-Kermit releases from the early onward. Kermit's mainstream use declined in the as TCP/IP-based alternatives like FTP and SCP dominated due to their speed and native network integration, yet development persisted for legacy and specialized needs. Maintenance continued with C-Kermit 9.0 (2011), which added compatibility and enhanced scripting for embedded systems. The protocol's 40th anniversary in highlighted its enduring educational impact, with oral histories from developers emphasizing Kermit's role in early computing connectivity and protocol principles. Following the 2011 open-source transition, independent development continued under the Open-Source Kermit Project, leading to C-Kermit 10.0, which entered beta testing in 2022 with ongoing updates; as of March 2025, Beta.12 includes improvements for modern operating systems, security enhancements, and support for platforms like (Open)VMS.

Technical Details

Protocol Mechanics

The Kermit protocol operates in an asynchronous, half-duplex mode, primarily over start-stop () serial connections, though advanced implementations also support TCP/IP sockets for network-based transfers. This design ensures compatibility with a wide range of hardware and software environments, allowing reliable communication even on unreliable links by prioritizing acknowledgment-based exchanges over speed. Sessions begin with the sender initiating contact, followed by a structured sequence of phases that handle , , and termination. The operational flow starts with the send-init phase, where the sender transmits an S packet containing proposed parameters such as maximum packet length (MAXL), timeout interval (TIME), 8th-bit prefixing for (QBIN), and repeat count for robustness (REPT). The receiver responds with an acknowledgment packet, either accepting the proposals or suggesting alternatives to reach a mutual agreement, enabling adaptive configuration based on link conditions. Once negotiated, the file header phase follows, in which the sender issues an F packet with the file name, optionally followed by an A packet with attributes such as size and modification date, prompting the receiver to acknowledge and prepare for data receipt. Data transfer then proceeds through sequential D packets containing file contents, succeeded by an end-of-file Z packet to signal completion of the current file, and finally a break B packet to conclude the entire session, with each phase confirmed by receiver acknowledgments. Key control characters facilitate these interactions: SOH (Start of Header, ASCII control-A) marks the beginning of packets, EOT (End of Transmission, ASCII control-D) signals termination where applicable, and ENQ (Enquiry, ASCII control-E) initiates server mode queries. In server mode, Kermit supports remote command execution, permitting operations like file sending (via S or G packets) or receiving (via R packets) without requiring a full user login on the remote system, thus enabling automated file management over the connection. This command-driven approach enhances usability in unattended or scripted environments.

Packet Structure and File Transfer Process

The Kermit protocol employs a compact packet format designed for transmission over low-bandwidth, error-prone serial connections. Each packet begins with a synchronization mark, typically the ASCII SOH (Start of Header, value 1), followed by a one-byte length field whose value is 32 plus the number of bytes from the sequence number through the end of the block check field (ranging from 3 to 94), a one-byte sequence number (0 to 63, 64, also excess-32 encoded), and a one-byte type field specifying the packet's purpose using a single uppercase ASCII letter. The data field, which varies in length up to 94 bytes depending on the packet type, carries the , such as initialization parameters, file metadata, or content chunks. The packet concludes with a block check field of 1 to 3 bytes for integrity verification, and packets are typically delimited by a . Relevant packet types for file transfer include the S (send-initiate) packet, which establishes session parameters like maximum packet and timeout; the F (file header) packet, which transmits the , with attributes such as , creation date, and permissions sent in an optional following A (attributes) packet; the D (data) packet, which conveys portions of the file contents; and the Z (end-of-file) packet, which signals completion of the current file. Additionally, the G (generic) packet serves commands in server mode, including handling for batch operations. To ensure compatibility with 7-bit channels and avoid interference from control characters, Kermit encodes data using a quoting mechanism that transforms potentially disruptive bytes into safe, printable ASCII sequences. Control characters (ASCII 0-31 and 127) are prefixed with a quote character, defaulting to '#' (e.g., SOH becomes '#A'), while 8-bit data on 7-bit links is handled by prefixing the high bit with another quote, defaulting to '&', allowing longer sequences without per-byte overhead in binary mode. Repeat counts for identical bytes (four or more) can be compressed using a third quote, defaulting to '', followed by the count and the byte (e.g., '#A' for eight SOHs), negotiated during initialization to maintain 7-bit safety. The process for a single file proceeds sequentially with positive acknowledgments to confirm . Following session via S packets, the sender transmits an F packet containing the , which the receiver acknowledges before entering data reception mode. The sender then dispatches D packets in sequence, each acknowledged by the receiver upon successful decoding and storage; packet sizes adapt based on negotiated maximum length to optimize throughput. Upon exhausting the file, the sender issues a packet, acknowledged by the receiver to close the file, after which a break packet (B) finalizes the transfer, confirmed by the receiver to conclude the session. Block checking enhances reliability through negotiable methods specified in the send-initiate phase. The default 1-byte check uses a simple 6-bit arithmetic sum of packet bytes, transformed to a printable character. For higher assurance, a 2-byte check employs a 12-bit modulo-4096 sum, or the robust 3-byte check applies a 16-bit CRC-CCITT , providing superior error detection on noisy links without significantly increasing overhead. For multiple-file transfers, the process extends the single-file sequence by iterating F, D-series, and Z packets for each file in the batch, preserving attributes per file via the F packets. In server-oriented scenarios, G packets facilitate batch initiation by encapsulating generic commands, enabling wildcard specifications or directory traversals without per-file renegotiation, culminating in a single B packet to end the group transfer.

Error Handling and Recovery Mechanisms

Kermit's error handling relies on a robust acknowledgment system where the receiver confirms correct packet receipt by sending an ACK (Y) packet containing the sequence number of the acknowledged packet. For missing or corrupted packets, detected via failure, the receiver sends a NAK (N) packet specifying the sequence number of the desired next packet, prompting retransmission. This positive and negative acknowledgment approach ensures selective retransmission only of erroneous packets, minimizing unnecessary data transfer. Retransmissions are triggered by timeouts, with the sender waiting a configurable interval—typically 5 seconds by default, adjustable up to 30 seconds based on link conditions—before resending the oldest unacknowledged packet. Each packet has a retry limit, usually around 5 attempts, after which the transaction aborts to prevent indefinite loops on faulty connections. The receiver may proactively send NAKs or re-ACKs during timeouts to accelerate recovery. Data integrity is verified using block checks appended to each packet, with three types negotiated during session initialization via the Send-Init packet. Type 1, the mandatory default, computes a 6-bit by summing the ASCII values of all packet characters (from to , excluding the check field itself), then applying the : = (s + ((s & 192) / 64)) & 63, where s is the sum, yielding a single printable ASCII character. Type 2 extends this to a 12-bit, two-character for improved detection, while Type 3 uses a 16-bit CRC-CCITT (X^16 + X^12 + X^5 + 1) encoded in three characters, offering the highest error detection for noisy links. In long-packet extensions, an additional header (always Type 1) protects the extended fields. To adapt to varying link quality, Kermit dynamically adjusts parameters during the transfer. Upon repeated errors indicated by NAKs, the sender may reduce the maximum packet length (initially negotiated up to 94 characters for short packets or 9024 for long packets), halving it progressively to shorter, more reliable sizes. Block check types can also switch mid-session to a stronger variant if errors persist, and timeout values scale with baud rate or system load for optimal performance. Additional safeguards include modulo-64 sequence numbering (0-63), which increments per packet and resets per file transaction, preventing wrap-around confusion within the typical short sizes (1-31 packets). File-level integrity is ensured post-transfer through the Attributes (A) packet, which conveys metadata like exact file length and modification date for comparison against the received file; discrepancies trigger an (E) packet to abort and report the issue. The (Z) packet, acknowledged before finalizing, further confirms complete reception.

Implementations

Software and Operating System Support

C-Kermit serves as the primary cross-platform implementation of the Kermit protocol, supporting a wide array of operating systems including Unix variants (such as , , and ), VMS/, macOS, and Windows. This portable software, written , enables terminal emulation, , and scripting over serial ports, modems, and network connections like SSH, FTP, and HTTP. Development continues with version 10.0 Beta.12, released on March 22, 2025, incorporating built-in SSH2 and SSL/TLS support added in earlier betas around 2021-2023. Early implementations targeted personal computing platforms, with first released in 1982 for PCs and compatibles running or PC-DOS, providing efficient file transfer via serial connections. This version, also known as IBM PC Kermit, laid the groundwork for broader adoption on x86 systems. Among modern open-source options, Kermit 95 provided advanced features for through , including terminal emulation and secure connections, with development continuing through open-source betas, the latest being version 3.0.0 Beta 7 released on August 10, 2025. Kermit functionality has been integrated into tools like minicom on systems, allowing seamless file transfers during serial sessions without switching applications. Historically, Kermit has seen hundreds of implementations across diverse operating systems, demonstrating exceptional portability for an era when standardization was limited. Notable examples include versions for (e.g., Kermit-80 for 8-bit systems like the Intertec Superbrain), (Kermit-65 under DOS and ProDOS), (C-Kermit 7.0), and embedded environments (E-Kermit and EKSW). Following the project's transition to open source in 2011, volunteer developers have continued updates, with recent releases in 2025. All Kermit software is freely available from the Kermit Project website hosted by , with full provided under a BSD-style to facilitate customization and porting to new platforms.

Hardware and Embedded Applications

Kermit has been adapted for resource-constrained embedded systems, particularly through implementations like E-Kermit, a compact ANSI C-based version designed for integration into and real-time applications. E-Kermit supports file sending and receiving, long packets, sliding windows with Go-Back-N or selective repeat options, repeat-count compression, and multiple block check types including 16-bit CRC, while automatically handling text/binary mode switching. Its footprint is approximately 15KB on platforms, reducible by disabling features or optimizing buffers, making it suitable for devices with limited memory such as . For even smaller environments, an assembly-language Kermit implementation exists for the 8051 , enabling basic text-mode send/receive operations over serial links. In legacy hardware contexts, Kermit facilitates firmware updates and data transfers in specialized equipment lacking modern networking, leveraging its compatibility without requiring kernel-mode drivers or complex interfaces like TCP/IP. It has been employed in medical devices, such as through the 8051-based implementation developed at for reliable serial file transfers in hospital systems. Similar uses appear in industrial controls and for over UART interfaces, where Kermit's error recovery ensures in noisy environments typical of such hardware. For router console access, Kermit remains a standard for loading configuration files or images via on devices like equipment, providing a simple alternative to TFTP in scenarios. Notable examples include satellite-related applications, where E-Kermit supports data exchanges in NASA's operations via ports and in Apex-EM ocean floats for hurricane tracking, demonstrating its robustness in remote, embedded systems. Kermit's advantages in these hardware settings stem from its minimal resource needs and direct compatibility with basic UART hardware, allowing operation on simple serial connections without additional protocol stacks. This portability, rooted in its early design for diverse systems, enables seamless integration across constrained platforms. In niche applications persisting into the 2020s, Kermit sustains retro computing communities, such as file transfers on the Commodore 64/128 using a dedicated with terminal emulation and basic protocol support, often over serial or user port adapters. It also finds use in secure environments avoiding IP-based protocols, like air-gapped industrial or legacy systems, where serial isolation prevents network vulnerabilities while enabling controlled updates.

Origin of the Name

The Kermit protocol was named after , the character from the television series , to evoke a sense of friendliness and approachability that mirrored the protocol's design goals of simplicity and accessibility for users across diverse computing environments. In May 1981, during a discussion at Columbia University's Center for Computing Activities, Frank da Cruz proposed the name while facing a Muppets calendar in the shared office space; the suggestion stemmed from his children's fondness for the show, highlighting the protocol's aim to be non-technical and memorable rather than burdened by jargon. Bill Catchings, co-designer of the protocol alongside da Cruz, supported the choice and later noted its alignment with a Celtic root meaning "free," resonating with Kermit's of open sharing among systems. The team deliberately avoided creating an , as initial attempts yielded awkward or unconvincing expansions that could confuse it with other protocols, opting instead for a straightforward, pronounceable name to enhance usability for non-experts. Permission to use the name was obtained from Henson Associates, Inc., the rights holders, ensuring its legitimacy. This whimsical branding extended to visual elements in Kermit's documentation, including frog-themed logos and mascots that reinforced the protocol's user-friendly image, as seen in early newsletters and the 1987 book by Frank da Cruz, which references the Muppet inspiration to underscore its cultural tie-in for broader adoption. The name's selection during that casual lab session emphasized Kermit's departure from intimidating technical nomenclature, prioritizing conceptual ease over complexity.

Licensing and Open Source Status

The Kermit protocol and its associated software were initially copyrighted by beginning in 1981, when the project originated at the university's Center for Computing Activities. The software was distributed free of charge for non-commercial, personal, and institutional use, subject to requirements for proper attribution to and the retention of copyright notices. Commercial vendors were permitted to implement the protocol in their products provided they included acknowledgments of the originators, but bundling the software itself with hardware or other commercial offerings required a separate license agreement with Columbia to generate revenue for ongoing development. From the mid-1980s onward, this model evolved to support self-funding of the project, with no royalties imposed on individual or organizational distributions but restrictions on resale or inclusion in products without permission. C-Kermit versions 7.0 and 8.0, released in the late and early , adopted more permissive terms that explicitly allowed inclusion in operating systems like and BSD variants without additional fees, marking an early step toward broader accessibility while maintaining Columbia's copyright oversight. The definitive shift to occurred in 2011, coinciding with the termination of the official Kermit Project at . At that point, the source code for C-Kermit 9.0, E-Kermit, and related programs was released under the Revised 3-Clause BSD License, enabling unrestricted use, modification, distribution, and commercialization with only requirements to retain the , disclaim warranties, and not use the authors' names for endorsement. continues to hold perpetual copyright on these works but imposes no enforcement on derivative implementations, which have incorporated contributions from a global community of developers. Source code for all major Kermit implementations is preserved in public archives hosted at kermitproject.org, free from commercial restrictions and supporting extensive ports across operating systems and embedded environments. Legally, the Kermit protocol as a cannot be copyrighted, permitting independent reimplementations worldwide; its name, derived from , operates distinctly from the Muppet trademarks owned by (now under Disney), as permission for the association was granted by Henson Associates in the protocol's early years.

Modern Relevance and Impact

Despite its age, the Kermit protocol remains essential in legacy systems such as mainframes and industrial control environments where reliable is required, as evidenced by ongoing support in tools like C-Kermit for platforms including VMS and DECSYSTEM-20. It continues to be used in scenarios with poor connectivity, leveraging its robust error correction to ensure over unreliable links, a design feature that makes it suitable for resource-constrained settings. Modern terminal emulators, such as , integrate Kermit support for file transfers alongside protocols like SSH, facilitating secure interactions with legacy hardware. Kermit pioneered reliable over serial lines, emphasizing adaptability and recovery, which influenced subsequent protocols like ZMODEM that addressed its speed limitations while building on its reliability principles. Its principles of robustness are cited in IETF RFCs, such as RFC 2839, which standardizes the Internet Kermit Service for authenticated file transfers over , highlighting its role in secure, cross-platform communication. In educational contexts, Kermit is examined in computing history curricula for its contributions to early networking, as documented in oral histories preserved by the . The protocol's 40th anniversary in prompted reflections on its enduring legacy, with events and publications underscoring its impact on standards. Today, Kermit has been largely superseded by faster protocols like FTP and SCP for high-bandwidth transfers, yet it is valued for its simplicity and security features, including resistance to vulnerabilities due to its packet-based structure. In embedded and IoT applications, E-Kermit enables lightweight implementations in devices without full operating systems, prioritizing low overhead. Looking ahead, active development of C-Kermit, with beta releases as recent as March 2025, suggests potential revival in low-power devices and as a secure fallback for communications in unreliable networks.

References

  1. http://www.columbia.edu/kermit/about.html
  2. http://www.columbia.edu/kermit/
  3. http://www.columbia.edu/kermit/ckermit.html
  4. https://www.kermitproject.org/kproto.pdf
  5. https://datatracker.ietf.org/doc/html/draft-columbia-kermit-service-02
  6. https://www.kermitproject.org/kermit.html
  7. https://datatracker.ietf.org/doc/html/rfc2839
  8. https://kermitproject.org/firstxfer.html
  9. http://www.columbia.edu/kermit/ftp/protocol/kuser.pdf
  10. https://www.amazon.com/Kermit-Transfer-Protocol-Frank-Cruz/dp/0932376886
  11. http://www.columbia.edu/kermit/biblio.html
  12. http://www.columbia.edu/kermit/ftp/protocol/history.txt
  13. https://kermitproject.org/newsn1.pdf
  14. https://www.kermitproject.org/ck70.html
  15. https://www.rfc-editor.org/rfc/rfc2839
  16. http://www.columbia.edu/kermit/ckc302.html
  17. https://www.kermitproject.org/fortieth.html
  18. https://www.computerhistory.org/collections/catalog/102746411
  19. https://www.kermitproject.org/whatsnew.html
  20. https://www.kermitproject.org/ckupdates.html
  21. https://kermitproject.org/kermit20/k20-5_3_235_5/documentation/kermitbook.pdf
  22. https://www.kermitproject.org/ckermit.html
  23. https://www.kermitproject.org/current.html
  24. https://www.kermitproject.org/ckw10beta.html
  25. https://www.kermitproject.org/mskermit.html
  26. https://www.kermitproject.org/k95faq.html
  27. https://man7.org/linux/man-pages/man1/minicom.1.html
  28. http://www.columbia.edu/kermit/archive.html
  29. https://www.kermitproject.org/archive.html
  30. http://www.columbia.edu/kermit/ek.html
  31. http://www.columbia.edu/kermit/ftp/c/i51aaaa.hlp
  32. http://www.columbia.edu/kermit/nasa.html
  33. http://www.columbia.edu/kermit/em-apex.html
  34. http://www.columbia.edu/kermit/c64.html
  35. https://archive.computerhistory.org/resources/access/text/2013/10/102746411-05-01-acc.pdf
  36. http://www.bitsavers.org/pdf/dec/_Books/_Digital_Press/daCruz_Kermit_A_File_Transfer_Protocol_1987.pdf
  37. http://www.kermitproject.org/
  38. https://www.vandyke.com/products/securecrt/features.html
  39. http://moscova.inria.fr/~doligez/zmodem/zmodem.txt
  40. http://www.kermitproject.org/misconceptions.html
  41. http://www.kermitproject.org/ckupdates.html
Add your contribution
Related Hubs
User Avatar
No comments yet.