ircII

ircII (pronounced “irk-two” or “i-r-c-two”) is a free, text-mode IRC client for Unix-like systems, written in C and first released in 1989. It is widely cited as the oldest IRC client still actively maintained. What earns ircII a place in a catalog of programming languages is not the client itself but the ircII scripting language: an event-driven macro and command language, interpreted by the client, that lets users define new commands, react to chat events, and program the behavior of their connection. That language became influential enough to be adopted and extended by an entire generation of descendant clients.

History & Origins

ircII was created by Michael Sandrof in 1989, only about a year after Jarkko Oikarinen wrote the original IRC server software in Finland. Where the protocol defined how clients and servers exchanged lines of text, ircII provided a polished, scriptable front end for actually using IRC from a Unix terminal. It quickly became, in the words of contemporaries, “the premiere client” of IRC’s early years and the reference implementation against which other clients measured themselves.

Sandrof extended the client steadily. In 1990 he added the Client-To-Client Protocol (CTCP) in version 2.1, a convention for embedding structured requests—VERSION, PING, TIME, and the famous ACTION (the /me emote)—inside ordinary private messages. In 1991, Troy Rollo contributed Direct Client-to-Client (DCC) in version 2.1.2, enabling peer-to-peer file transfers and direct chats negotiated through the server but carried over a separate connection. Both protocols originated in ircII and were later widely copied; they remain part of how IRC clients interoperate today.

By the mid-1990s, version 2.8.2 had come to be seen as the definitive ircII release. Its stability and feature set were so admired that, in the autumn of 1994, developers who wanted to push the scripting language further forked it into EPIC (the Enhanced Programmable ircII Client). Other Unix clients—BitchX and ScrollZ among them—likewise trace their lineage back to ircII.

Design Philosophy

ircII reflects a distinctly Unix sensibility: do one thing well, stay small and fast, and make the tool programmable by its user. The client has no menus, no sounds, and no pop-up windows—just a status line and a command input bound to a termcap-driven screen. Everything beyond basic chatting is meant to be added through scripting rather than baked into the binary.

The scripting language is built around a few core ideas:

• Commands are the primitive. Everything the user types either is a message to a channel or begins with a / command. Scripts compose, redefine, and create commands.
• Aliases extend the command set. An ALIAS binds a name to a block of ircII code, so user-defined commands look and behave like built-ins.
• The client is event-driven. The ON construct registers handlers that fire when something happens—an incoming message, a join, a CTCP request, a server numeric—turning the client into a reactive program.
• Values are text. Variables hold strings; arithmetic and comparison coerce as needed. Arguments arrive through positional expandos ($0, $1, …) and $* for “everything.”

Key Features

Aliases

An alias defines a new command as a block of script. Special $ expandos pull in arguments: $0 is the first word, $* is the whole argument list.

alias hi {
    msg $0 Hello there, $0! Welcome.
}

# Used as:  /hi nick

Event Hooks with ON

ON is the heart of ircII automation. It attaches an action to an event, optionally matching a pattern. Here a script greets anyone who joins a channel:

on join * {
    if (\[$1] != \[#secret]) {
        msg $1 Welcome to $1, $0!
    }
}

The event’s own arguments fill $0, $1, and so on—for a JOIN, that is the nickname and the channel.

Variables, Control Flow, and Functions

ircII provides assignment, conditionals, and loops, along with a large library of built-in functions invoked with $func(...):

# Assignment
@ count = 0

# Conditional and loop
while (count < 3) {
    echo Line number ${count + 1}
    @ count = count + 1
}

# Built-in functions
echo Lowercase: $tolower(HELLO)
echo Third word: $word(2 alpha beta gamma delta)

CTCP and DCC

Because ircII originated CTCP and DCC, its scripting language exposes them directly. Scripts can answer CTCP requests, send /me actions, and initiate or accept DCC file transfers and direct chats—capabilities that made ircII a capable automation platform well before dedicated bot software was common.

Evolution

After the classic 2.x series, ircII moved to date-based version numbers (for example 20030314), a scheme it still uses. A buffer-overflow vulnerability in older builds prompted security fixes in the early-2000s releases. The project later added OpenSSL support for encrypted TLS connections to IRC servers, keeping it usable on modern networks that expect secure links.

Much of ircII’s lasting impact, though, flowed through its forks. EPIC in particular treated the scripting language as a first-class concern, expanding it over decades to satisfy script authors and eventually adding UTF-8 support, modularity, and the option to embed other scripting languages entirely. The ircII dialect thus seeded a whole branch of Unix IRC clients whose scripts were broadly portable across the family.

Current Relevance

ircII is still maintained—an unusual distinction for software with roots in 1989. Recent releases, including 20260115 in January 2026, continue under maintainer Matthew R. Green, distributed under the BSD-3-Clause license. It is packaged by most Linux distributions and the BSDs, and remains a practical choice for users who want a fast, keyboard-driven client that works well over SSH and inside terminal multiplexers like screen and tmux.

In an era dominated by graphical and web-based chat, ircII’s audience is smaller than it once was, but it endures among Unix traditionalists, low-bandwidth users, and anyone who values a chat client they can fully program. Its scripting language—and the larger family of dialects it spawned—stands as one of the earliest widely used examples of an application embedding a small, event-driven language so that ordinary users could automate and reshape the tool.

Why It Matters

ircII demonstrated, very early, the power of giving an application its own embedded scripting language. Long before “scriptable” was a checkbox feature, ircII users were writing aliases and ON hooks to build bots, custom commands, and elaborate interfaces. The CTCP and DCC protocols it pioneered became permanent fixtures of IRC, and its scripting dialect propagated through EPIC, BitchX, ScrollZ, and others. As the oldest IRC client still maintained, ircII is both a living artifact of the early internet and a quiet milestone in the history of end-user programmability.