Simple IRC Client

The Origins of IRC

Internet Relay Chat (IRC) is a text-based communication protocol created in August 1988 by Jarkko Oikarinen at the University of Oulu in Finland. Originally designed as a replacement for a program called MUT (MultiUser Talk) on the OuluBox BBS, IRC quickly spread across the internet. By mid-1989, there were approximately 40 servers worldwide. The first IRC server was tolsun.oulu.fi, and the first network formed when Jyrki Kuoppala installed a second server after the University of Oulu released the IRC code.

IRC operates on a client-server model. Users run an IRC client application that connects to an IRC server. Servers can be linked together to form a network, allowing thousands of users across different servers to communicate with each other. Conversations take place in channels (prefixed with #), which are group chat rooms that anyone can create or join, as well as through private messages between individual users.

The protocol was formalized in RFC 1459 (May 1993) and later updated in RFC 2812 (2000). IRC reached its peak between 2004 and 2005 with approximately 10 million simultaneous users. While usage declined with the rise of social media, IRC remains actively used — according to IRCLab, around 300,000 users connect daily across more than 120,000 channels. Open-source projects, developer communities, and technology organizations continue to value IRC for its openness, simplicity, and lack of corporate control.

IRC also played a notable role in history — it was used to report on the 1991 Soviet coup d'état attempt during a media blackout, demonstrating the power of decentralized communication.

How IRC Works

At its core, IRC is a simple text-based protocol. When you connect to an IRC server, you choose a nickname and can then join any number of channels. Messages you send to a channel are broadcast to everyone in that channel. The protocol supports a range of features:

• Channels — group chat rooms, typically prefixed with # (e.g., #linux, #python)
• Private messages — direct one-on-one conversations between users
• Nicknames — unique display names that can be registered with network services
• Operators — channel and server administrators who manage access and moderation
• File transfers — direct file sharing through DCC (Direct Client-to-Client) connections
• SSL/TLS — encrypted connections for privacy and security

The Modern Protocol: IRCv3

IRC continues to evolve through the IRCv3 Working Group, a community effort to develop modern extensions for the protocol. The IRCv3 specifications build upon the original RFCs while maintaining backward compatibility, ensuring that older clients and servers continue to work alongside newer ones.

Key improvements introduced by IRCv3 include:

• SASL authentication — standardized account login for faster, more secure registration
• Message tags — extensible metadata attached to messages for features like reactions and replies
• Chat history — server-side message history so you can catch up on missed conversations
• Server time — accurate timestamps on messages for proper chronological display
• Account tracking — awareness of user account information across the network
• Batch messages — grouping related messages for efficient delivery
• STS (Strict Transport Security) — automatic secure connection upgrades

The IRCv3 Working Group includes participation from major projects like InspIRCd, UnrealIRCd, WeeChat, HexChat, Irssi, and many others. Active development continues on features such as account registration, Unicode nickname support, and client avatars.

Popular IRC Networks

IRC is decentralized — there is no single "IRC" service. Instead, there are many independent networks, each with their own servers, rules, and communities. According to IRCLab, around 300,000 users connect to IRC daily across more than 120,000 channels. Here are the most notable networks:

Popular IRC Clients

There are many IRC clients available for every platform, from graphical applications to terminal-based tools. Here are some of the most popular ones:

Why IRC Still Matters

In an era of proprietary chat platforms, IRC stands out for several reasons:

• Open protocol — no single company controls IRC; anyone can run servers, build clients, and participate
• Privacy — no mandatory account creation, no tracking, no ads, no data harvesting
• Lightweight — text-based protocol that works on minimal hardware and bandwidth
• Mature ecosystem — decades of development have produced robust, battle-tested software
• Extensibility — bots, scripts, and integrations are straightforward to build
• Community governance — networks are typically run by volunteers for the benefit of users

The IRC Protocol

IRC is one of the simplest network protocols to implement. At its core, it's just text messages sent over a TCP connection. Each message is a single line terminated by \r\n (carriage return + line feed). To build a minimal IRC client, you only need to understand a handful of commands:

• NICK <nickname> — set your nickname
• USER <username> 0 * :<realname> — identify yourself to the server
• JOIN <#channel> — join a channel
• PRIVMSG <target> :<message> — send a message to a channel or user
• PING <token> / PONG <token> — keep-alive mechanism (reply to server PINGs)
• QUIT :<message> — disconnect from the server

A typical connection flow looks like this: open a TCP socket to the server on port 6667 (or 6697 for TLS), send NICK and USER to register, respond to PING messages to stay connected, then JOIN channels and send PRIVMSG to chat.

Every example below connects to Libera Chat, joins #test, sends a message, and then disconnects. They all handle the PING/PONG keep-alive that servers require.

Python

Python's built-in socket module makes this straightforward. This example uses SSL/TLS for a secure connection.

import socket
import ssl

server = "irc.libera.chat"
port = 6697
nick = "mybot"
channel = "#test"

sock = socket.create_connection((server, port))
irc = ssl.create_default_context().wrap_socket(sock, server_hostname=server)

def send(msg):
    irc.send(f"{msg}\r\n".encode())

send(f"NICK {nick}")
send(f"USER {nick} 0 * :{nick}")

buf = b""
while True:
    buf += irc.recv(4096)
    while b"\r\n" in buf:
        line, buf = buf.split(b"\r\n", 1)
        line = line.decode("utf-8", errors="replace")
        print(line)

        if line.startswith("PING"):
            send("PONG" + line[4:])

        # 001 = RPL_WELCOME, meaning registration is complete
        if " 001 " in line:
            send(f"JOIN {channel}")
            send(f"PRIVMSG {channel} :Hello from Python!")
            send("QUIT :Bye")
            irc.close()
            exit()

JavaScript (Node.js)

Node.js provides the tls module for secure TCP connections.

const tls = require("tls");

const server = "irc.libera.chat";
const port = 6697;
const nick = "mybot";
const channel = "#test";

const socket = tls.connect(port, server, () => {
  send(`NICK ${nick}`);
  send(`USER ${nick} 0 * :${nick}`);
});

function send(msg) {
  socket.write(msg + "\r\n");
}

let buffer = "";
socket.setEncoding("utf8");
socket.on("data", (data) => {
  buffer += data;
  const lines = buffer.split("\r\n");
  buffer = lines.pop();

  for (const line of lines) {
    console.log(line);

    if (line.startsWith("PING")) {
      send("PONG" + line.slice(4));
    }

    // 001 = RPL_WELCOME
    if (line.includes(" 001 ")) {
      send(`JOIN ${channel}`);
      send(`PRIVMSG ${channel} :Hello from Node.js!`);
      send("QUIT :Bye");
    }
  }
});

Go

Go's standard library has everything needed with crypto/tls and bufio.

package main

import (
	"bufio"
	"crypto/tls"
	"fmt"
	"strings"
)

func main() {
	server := "irc.libera.chat:6697"
	nick := "mybot"
	channel := "#test"

	conn, err := tls.Dial("tcp", server, nil)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	send := func(msg string) {
		fmt.Fprintf(conn, "%s\r\n", msg)
	}

	send("NICK " + nick)
	send("USER " + nick + " 0 * :" + nick)

	scanner := bufio.NewScanner(conn)
	for scanner.Scan() {
		line := scanner.Text()
		fmt.Println(line)

		if strings.HasPrefix(line, "PING") {
			send("PONG" + line[4:])
		}

		// 001 = RPL_WELCOME
		if strings.Contains(line, " 001 ") {
			send("JOIN " + channel)
			send("PRIVMSG " + channel + " :Hello from Go!")
			send("QUIT :Bye")
			return
		}
	}
}

Rust

Using Rust's standard library with the native-tls crate for TLS support.

use native_tls::TlsConnector;
use std::io::{BufRead, BufReader, Write};
use std::net::TcpStream;

fn send(stream: &mut impl Write, msg: &str) {
    write!(stream, "{msg}\r\n").unwrap();
    stream.flush().unwrap();
}

fn main() {
    let server = "irc.libera.chat";
    let port = 6697;
    let nick = "mybot";
    let channel = "#test";

    let connector = TlsConnector::new().unwrap();
    let tcp = TcpStream::connect(format!("{server}:{port}")).unwrap();
    let tls = connector.connect(server, tcp).unwrap();

    let mut reader = BufReader::new(tls);

    send(reader.get_mut(), &format!("NICK {nick}"));
    send(reader.get_mut(), &format!("USER {nick} 0 * :{nick}"));

    let mut line = String::new();
    while reader.read_line(&mut line).unwrap() > 0 {
        print!("{line}");

        if line.starts_with("PING") {
            let pong = format!("PONG{}", &line[4..].trim());
            send(reader.get_mut(), &pong);
        }

        // 001 = RPL_WELCOME
        if line.contains(" 001 ") {
            send(reader.get_mut(), &format!("JOIN {channel}"));
            send(reader.get_mut(), &format!("PRIVMSG {channel} :Hello from Rust!"));
            send(reader.get_mut(), "QUIT :Bye");
            break;
        }

        line.clear();
    }
}

// Cargo.toml:
// [dependencies]
// native-tls = "0.2"

C

A plain TCP example using POSIX sockets. For production use, you would add TLS via OpenSSL.

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>

static int irc_fd;

void irc_send(const char *msg) {
    dprintf(irc_fd, "%s\r\n", msg);
}

/* Strip trailing \r\n */
void chomp(char *s) {
    size_t len = strlen(s);
    while (len > 0 && (s[len - 1] == '\r' || s[len - 1] == '\n'))
        s[--len] = '\0';
}

int main(void) {
    const char *server = "irc.libera.chat";
    const char *port = "6667";
    const char *nick = "mybot";
    const char *channel = "#test";

    struct addrinfo hints = { .ai_socktype = SOCK_STREAM }, *res;
    getaddrinfo(server, port, &hints, &res);

    irc_fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    connect(irc_fd, res->ai_addr, res->ai_addrlen);
    freeaddrinfo(res);

    char buf[512];
    snprintf(buf, sizeof(buf), "NICK %s", nick);
    irc_send(buf);
    snprintf(buf, sizeof(buf), "USER %s 0 * :%s", nick, nick);
    irc_send(buf);

    char line[512];
    FILE *fp = fdopen(dup(irc_fd), "r");
    while (fgets(line, sizeof(line), fp)) {
        chomp(line);
        printf("%s\n", line);

        if (strncmp(line, "PING", 4) == 0) {
            snprintf(buf, sizeof(buf), "PONG%s", line + 4);
            irc_send(buf);
        }

        /* 001 = RPL_WELCOME */
        if (strstr(line, " 001 ")) {
            snprintf(buf, sizeof(buf), "JOIN %s", channel);
            irc_send(buf);
            snprintf(buf, sizeof(buf), "PRIVMSG %s :Hello from C!", channel);
            irc_send(buf);
            irc_send("QUIT :Bye");
            break;
        }
    }

    fclose(fp);
    close(irc_fd);
    return 0;
}

/* Compile: gcc -o irc irc.c */

Java

Java's SSLSocketFactory provides TLS out of the box.

import javax.net.ssl.SSLSocketFactory;
import java.io.*;

public class IrcClient {
    static OutputStream raw;

    static void send(String msg) throws Exception {
        raw.write((msg + "\r\n").getBytes("UTF-8"));
        raw.flush();
    }

    public static void main(String[] args) throws Exception {
        String server = "irc.libera.chat";
        int port = 6697;
        String nick = "mybot";
        String channel = "#test";

        var socket = SSLSocketFactory.getDefault()
            .createSocket(server, port);
        raw = socket.getOutputStream();
        var in = new BufferedReader(
            new InputStreamReader(socket.getInputStream()));

        send("NICK " + nick);
        send("USER " + nick + " 0 * :" + nick);

        String line;
        while ((line = in.readLine()) != null) {
            System.out.println(line);

            if (line.startsWith("PING")) {
                send("PONG" + line.substring(4));
            }

            // 001 = RPL_WELCOME
            if (line.contains(" 001 ")) {
                send("JOIN " + channel);
                send("PRIVMSG " + channel + " :Hello from Java!");
                send("QUIT :Bye");
                break;
            }
        }

        socket.close();
    }
}

Ruby

Ruby's openssl standard library handles TLS connections.

require "socket"
require "openssl"

server = "irc.libera.chat"
port = 6697
nick = "mybot"
channel = "#test"

tcp = TCPSocket.new(server, port)
ctx = OpenSSL::SSL::SSLContext.new
irc = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
irc.connect

def irc_send(conn, msg)
  conn.write("#{msg}\r\n")
end

irc_send(irc, "NICK #{nick}")
irc_send(irc, "USER #{nick} 0 * :#{nick}")

while line = irc.gets
  line.chomp!
  puts line

  if line.start_with?("PING")
    irc_send(irc, "PONG#{line[4..]}")
  end

  # 001 = RPL_WELCOME
  if line.include?(" 001 ")
    irc_send(irc, "JOIN #{channel}")
    irc_send(irc, "PRIVMSG #{channel} :Hello from Ruby!")
    irc_send(irc, "QUIT :Bye")
    break
  end
end

irc.close

C#

Using .NET's SslStream for a secure connection.

using System.Net.Security;
using System.Net.Sockets;
using System.Text;

var server = "irc.libera.chat";
var port = 6697;
var nick = "mybot";
var channel = "#test";

using var tcp = new TcpClient(server, port);
using var ssl = new SslStream(tcp.GetStream());
ssl.AuthenticateAsClient(server);

using var reader = new StreamReader(ssl, Encoding.UTF8);

void Send(string msg)
{
    var bytes = Encoding.UTF8.GetBytes(msg + "\r\n");
    ssl.Write(bytes);
    ssl.Flush();
}

Send($"NICK {nick}");
Send($"USER {nick} 0 * :{nick}");

string? line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine(line);

    if (line.StartsWith("PING"))
        Send("PONG" + line[4..]);

    // 001 = RPL_WELCOME
    if (line.Contains(" 001 "))
    {
        Send($"JOIN {channel}");
        Send($"PRIVMSG {channel} :Hello from C#!");
        Send("QUIT :Bye");
        break;
    }
}

PHP

PHP can open TLS sockets using the ssl:// stream wrapper.

<?php

$server = "irc.libera.chat";
$port = 6697;
$nick = "mybot";
$channel = "#test";

$irc = stream_socket_client("ssl://{$server}:{$port}");

function irc_send($conn, string $msg): void {
    fwrite($conn, "{$msg}\r\n");
}

irc_send($irc, "NICK {$nick}");
irc_send($irc, "USER {$nick} 0 * :{$nick}");

while ($line = fgets($irc)) {
    $line = rtrim($line, "\r\n");
    echo $line . "\n";

    if (str_starts_with($line, "PING")) {
        irc_send($irc, "PONG" . substr($line, 4));
    }

    // 001 = RPL_WELCOME
    if (str_contains($line, " 001 ")) {
        irc_send($irc, "JOIN {$channel}");
        irc_send($irc, "PRIVMSG {$channel} :Hello from PHP!");
        irc_send($irc, "QUIT :Bye");
        break;
    }
}

fclose($irc);

Next Steps

These examples cover the bare minimum. A real IRC client would need to handle:

• Message parsing — properly parse the IRC message format (:prefix COMMAND params :trailing)
• Multiple channels — track joined channels and route messages accordingly
• Nick collision — handle 433 ERR_NICKNAMEINUSE by trying alternative nicknames
• Reconnection — automatically reconnect on connection loss
• SASL authentication — log in to registered accounts via the IRCv3 SASL mechanism
• CAP negotiation — request IRCv3 capabilities for modern features like message history and tags
• User interface — a terminal UI, graphical interface, or web frontend for interactive use