IRC Bot Programmieren: Frameworks für Python, Node.js, Go & Rust

In diesem “In a Nutshell Tutorial” möchte ich Dir zeigen, wie schnell Du einen kleinen IRC-Bot in unterschiedlichen Sprachen, mit unterschiedlichen Frameworks schreiben kannst.

Warum Python?

Denn Python ist derzeit eines der beliebtesten Programmiersprachen und bietet unzählige Bibliotheken für Textverarbeitung. Ich arbeite auch beruflich viel mit Python-Frameworks wie Fast-API etc und mag es solche System zu integrieren.

Warum Node.js?

Serverseitig mit Node.js, sehr modern und die Integration könnte in zahlreichen JS-Frameworks eingebunden werden. Wer viel programmiert, wird an Node.js schwer vorbeikommen.

Warum Go?

Go ist perfekt für IRC-Bots wegen seiner eingebauten Concurrency-Features (Goroutines) und der einfachen Netzwerkprogrammierung. Die kompilierten Binaries sind klein und schnell - ideal für Bots, die 24/7 laufen sollen.

Warum Rust?

Egal, welches Projekt ansteht, eine Durchführung mit Rust wird immer geprüft. Daher auch hier eine schnelle Durchführung mit Rust, um die Einfachheit zu verdeutlichen. Rust bietet Memory Safety ohne Garbage Collector - perfekt für langlebige Bots.

Grundprinzip eines IRC Bots

Um ein ordentliches Gerüst zu bauen, oder den Anfang und die Mitte zu finden, muss man die Kernaufgaben eines IRC-Bots kurz notieren oder verinnerlichen. Anstatt mit UML-Diagrammen oder Struktogrammen, arbeiten wir mit einer einfachen Aufgaben-Liste

###Alle IRC Bots machen im Kern das:

TCP-Verbindung zum IRC-Server Nick setzen Optional Auth (NickServ / SASL) Channel joinen Nachrichten lesen (Events) Auf PRIVMSG reagieren ggf. antworten

In der Erweiterung können wir die Aufgaben oder Funktionen natürlich noch bis ins bodenlose erweitern. Aber wir werden uns hier noch ein Plugin-System anschauen und Async-Methoden

wir haben viele Tutorials, die von 0 an alles erläutern, in diesem “In a nutshell tutorial” gehen wir von den absoluten Grundkenntnissen aus und starten sofort mit den Installationen und notwendigen “requirements”

Python – irc (einfachster Einstieg)

Installation

pip install irc

Minimal Bot

import irc.bot

class MyBot(irc.bot.SingleServerIRCBot):
    def __init__(self):
        server = [("irc.IRC-Mania.de", 6667)]
        nickname = "MyPyBot"
        irc.bot.SingleServerIRCBot.__init__(self, server, nickname, nickname)

    def on_welcome(self, connection, event):
        connection.join("#ircmania")

    def on_pubmsg(self, connection, event):
        msg = event.arguments[0]
        if msg == "!ping":
            connection.privmsg(event.target, "pong")

if __name__ == "__main__":
    MyBot().start()

Was passiert hier?

• on_welcome → join channel
• on_pubmsg → Nachrichten im Channel
• einfache String-Logik für Commands

Das Prinzip sollte man hier schon verstanden haben, jetzt darf man sich mit Frameworks beschäftigen. Natürlich geht es mit Frameworks noch einfacher. Python bietet zahlreiche geeignete Frameworks.

Python – irc3 (moderner & modular)

irc3 ist ein modernes, plugin-basiertes IRC Framework für Python. Es bietet eingebaute Command-Handler, automatische Reconnection-Logik und eine saubere Plugin-Architektur. Perfekt für größere Bots mit vielen Features.

Installation

pip install irc3

Bot

import irc3
from irc3.plugins.command import command

@irc3.plugin
class Plugin:
    def __init__(self, bot):
        self.bot = bot

    @command
    def ping(self, mask, target, args):
        """!ping command"""
        self.bot.privmsg(target, "pong")

config = dict(
    nick='MyIrc3Bot',
    autojoins=['#ircmania'],
    host='irc.IRC-Mania.de',
    port=6667,
    includes=['irc3.plugins.core', __name__],
)

irc3.IrcBot(**config).run()

Vorteil: Plugins + Commands out of the box

Python – pydle (async & modern)

pydle ist ein modernes, async-basiertes IRC Framework. Der Hauptvorteil gegenüber irc3 ist die native async/await-Unterstützung, was für I/O-intensive Bots ideal ist. pydle ist leichter und flexibler, aber hat weniger eingebaute Features als irc3.

Installation

pip install pydle

Bot

import pydle

class MyBot(pydle.Client):
    async def on_connect(self):
        await self.join('#ircmania')

    async def on_message(self, target, source, message):
        if message == "!ping":
            await self.message(target, "pong")

client = MyBot("MyPydleBot")
client.run("irc.IRC-Mania.de", tls=False)

Node.js – irc-framework

Node.js ist perfekt für IRC-Bots wegen seiner Event-basierten Architektur. Die non-blocking I/O-Model passt ideal zu IRC’s Nachrichtensystem. irc-framework ist die beliebteste Bibliothek mit excellenten Reconnection-Features und Plugin-System.

Installation

npm install irc-framework

Bot

const IRC = require('irc-framework');

const bot = new IRC.Client();

bot.connect({
    host: 'irc.IRC-Mania.de',
    port: 6667,
    nick: 'MyNodeBot'
});

bot.on('registered', () => {
    bot.join('#ircmania');
});

bot.on('message', (event) => {
    if (event.message === '!ping') {
        bot.say(event.target, 'pong');
    }
});

Go – go-ircevent

Installation

go get github.com/thoj/go-ircevent

Bot

package main

import (
    "github.com/thoj/go-ircevent"
    "fmt"
)

func main() {
    bot := irc.IRC("MyGoBot", "MyGoBot")
    
    bot.AddCallback("001", func(e irc.Event) {
        bot.Join("#ircmania")
    })
    
    bot.AddCallback("PRIVMSG", func(e irc.Event) {
        if e.Message() == "!ping" {
            bot.Privmsg(e.Arguments[0], "pong")
        }
    })
    
    err := bot.Connect("irc.IRC-Mania.de:6667")
    if err != nil {
        fmt.Println(err)
        return
    }

    bot.Loop()
}

Rust – irc crate

Rust ist eine gute Wahl für IRC-Bots, da es Memory Safety ohne Garbage Collector bietet. Das bedeutet, dass Rust-Bots langlebig und stabil sind.

Installation

cargo add irc

Bot

use irc::client::prelude::*;

fn main() {
    let config = Config {
        nickname: Some("MyRustBot".to_owned()),
        server: Some("irc.IRC-Mania.de".to_owned()),
        channels: vec!["#ircmania".to_owned()],
        ..Default::default()
    };

    let mut client = Client::from_config(config).unwrap();
    client.identify().unwrap();

    for message in client.stream().unwrap() {
        if let Ok(message) = message {
            if let Command::PRIVMSG(_, ref msg) = message.command {
                if msg == "!ping" {
                    let _ = client.send_privmsg("#ircmania", "pong");
                }
            }
        }
    }
}

IRC-Bots in Python Web-Frameworks integrieren

Ja, Du kannst IRC-Bots hervorragend in moderne Python-Web-Frameworks integrieren! Das eröffnet ganz neue Möglichkeiten für Webanwendungen mit Chat-Integration.

Übersicht: Python Web-Frameworks für IRC-Bots

FastAPI Integration (perfekt…fast )

from fastapi import FastAPI, WebSocket
import asyncio
import threading
from irc.bot import SingleServerIRCBot

app = FastAPI()

class IRCBot(SingleServerIRCBot):
    def __init__(self):
        server = [("irc.IRC-Mania.de", 6667)]
        nickname = "FastAPIBot"
        super().__init__(server, nickname, nickname)
        self.messages = []

    def on_pubmsg(self, connection, event):
        msg = event.arguments[0]
        self.messages.append({
            "channel": event.target,
            "user": event.source.split("!")[0],
            "message": msg,
            "timestamp": asyncio.get_event_loop().time()
        })

irc_bot = IRCBot()
threading.Thread(target=irc_bot.start, daemon=True).start()

@app.get("/messages")
async def get_messages():
    return {"messages": irc_bot.messages[-20:]}

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        await websocket.send_json({"messages": irc_bot.messages[-5:]})
        await asyncio.sleep(1)

Streamlit Integration (Sehr gut)

import streamlit as st
import threading
from irc.bot import SingleServerIRCBot

class StreamlitIRCBot(SingleServerIRCBot):
    def __init__(self):
        super().__init__([("irc.IRC-Mania.de", 6667)], "StreamlitBot", "StreamlitBot")
        if 'messages' not in st.session_state:
            st.session_state.messages = []

    def on_pubmsg(self, connection, event):
        st.session_state.messages.append({
            "channel": event.target,
            "user": event.source.split("!")[0],
            "message": event.arguments[0],
            "time": time.strftime("%H:%M:%S")
        })

if 'irc_bot' not in st.session_state:
    st.session_state.irc_bot = StreamlitIRCBot()
    threading.Thread(target=st.session_state.irc_bot.start, daemon=True).start()

st.title("IRC Bot Dashboard")
for msg in reversed(st.session_state.messages[-10:]):
    st.chat_message(msg["user"]).write(f"**{msg['channel']}**: {msg['message']}")

Django Integration (Gut)

# views.py
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from irc.bot import SingleServerIRCBot
import threading

class DjangoIRCBot(SingleServerIRCBot):
    def __init__(self):
        super().__init__([("irc.IRC-Mania.de", 6667)], "DjangoBot", "DjangoBot")

django_bot = DjangoIRCBot()
threading.Thread(target=django_bot.start, daemon=True).start()

@csrf_exempt
def send_message(request):
    if request.method == 'POST':
        channel = request.POST.get('channel')
        message = request.POST.get('message')
        django_bot.connection.privmsg(channel, message)
        return JsonResponse({'status': 'sent'})

Vorteile der Framework-Integration

• Web-Interface: Steuerung über Browser statt Kommandozeile
• API-Endpunkte: Andere Anwendungen können mit dem Bot kommunizieren
• Datenpersistenz: Speicherung von Chat-Verläufen in Datenbanken
• Monitoring: Live-Dashboards für Bot-Aktivitäten
• Multi-User: Mehrere Benutzer können den Bot steuern
• Echtzeit-Features: WebSocket-Integration für Live-Updates

Ich hoffe, diese kurzen Einführungen machen Lust, Dich wieder ein wenig mit IRC-Bots bzw. dem Internet Relay Chat zu beschäftigen. Dafür gibt es diese Seite. Du findest auf dieser Seite, aber auch auf IRC-Mania.de zahlreiche ausführliche Anfänger-Tutorials.

Was alle Bots gemeinsam haben

Am Ende kochen alle Programmiersprachen mit dem selben Rezept, aber nicht immer mit dem selben Wasser:

Typische IRC-Bot Features (nächster Level)

Wenn Du weitergehst, kommen diese Klassiker:

🔹 Reconnect Logic Wichtig: IRC droppt oft Verbindungen!

Oben haben wir mit einfachen Funktionen die Programmierung gestartet. Wenn Du etwas größeres Programmieren magst, dann lohnt es sich, ein kleines Funktionsgerüst zu basteln. Es müssen keine Klassendiagramme sein, keine Use-Case-Diagramme, aber eine grobe Richtung wäre schon gut.

Ich zeige Dir eine Production-ready IRC Bot Architektur, plus wie Du Multi-Channel + async/Threads sauber trennst, ohne dass der Bot nach 2 Tagen crasht oder Messages verliert.

Production-ready IRC Bot Architektur

Zielbild

┌─────────────────┐
│  IRC Client     │ ← Verbindung zum Server
└─────────┬───────┘
│
┌─────────▼───────┐
│ Event Dispatcher│ ← Events routing
└───────┬─┬───────┘
│ │
┌───────▼─▼───────┐
│ Plugin System   │ ← Features
└─────────────────┘
│
┌────────▼─┐  ┌────▼────────┐
│ Plugin A │  │ Plugin B    │  ← Features
└──────────┘  └─────────────┘

Architektur

bot/
 ├── core.py        (IRC client)
 ├── dispatcher.py  (event routing)
 ├── plugins/
 │     ├── ping.py
 │     ├── logger.py
 │     └── admin.py
 └── main.py

Core Bot (async + reconnect)

import pydle
import asyncio

class CoreBot(pydle.Client):
    def __init__(self, nickname, channels):
        super().__init__(nickname)
        self.channels = channels
        self.plugins = []
        self.reconnect_delay = 5

    async def on_connect(self):
        for channel in self.channels:
            await self.join(channel)

    async def on_disconnect(self, expected):
        while True:
            try:
                await self.reconnect()
                break
            except:
                await asyncio.sleep(self.reconnect_delay)

    async def on_message(self, target, source, message):
        for plugin in self.plugins:
            await plugin.handle_message(self, target, source, message)

    def register_plugin(self, plugin):
        self.plugins.append(plugin)

Plugin System

class PingPlugin:
    async def handle_message(self, bot, target, source, message):
        if message == "!ping":
            await bot.message(target, "pong")

Main Runner

from core import CoreBot
from plugins.ping import PingPlugin

bot = CoreBot("MyBot", ["#dev", "#test"])
bot.register_plugin(PingPlugin())

bot.run("irc.libera.chat", tls=False)

Multi-Channel Verhalten

Das passiert automatisch:

• Bot join #dev + #test
• Bot reagiert unabhängig vom Channel

Threaded Architecture (wenn Du NICHT async nutzt)

Alternative (klassisch, z. B. Python irc lib):

Problem:

IRC Loop blockiert → Plugins bremsen alles

Lösung: Worker Threads IRC Thread ───► Event Queue ───► Worker Threads Beispiel Pattern:

from queue import Queue
import threading

event_queue = Queue()

def worker():
    while True:
        event = event_queue.get()
        handle_event(event)

threading.Thread(target=worker, daemon=True).start()

IRC Callback:

def on_message(msg):
    event_queue.put(msg)

Vorteil:

• IRC bleibt schnell
• CPU-heavy tasks blockieren NICHT

Production Features (wichtig in echten Bots)

1. Auto-Reconnect

async def on_disconnect(self, expected):
    while True:
        try:
            await self.reconnect()
            break
        except:
            await asyncio.sleep(5)

2. Rate Limiting (Flood Protection)

IRC Server kicken Dich sonst.

import time

last_send = 0

def safe_send(bot, target, msg):
    global last_send
    if time.time() - last_send < 1:
        time.sleep(1)
    bot.message(target, msg)
    last_send = time.time()

3. SASL / NickServ Auth

CAP REQ :sasl
AUTHENTICATE PLAIN

nötig für:

• freigehostete Nicks
• IRC Networks wie Libera

4. Logging System

async def on_message(self, target, source, message):
    print(f"[{target}] {source}: {message}")

besser:

• SQLite / PostgreSQL
• Elasticsearch (für große Bots)

5. Plugin Hot Reload (advanced)

import importlib

def reload_plugin(module):
    importlib.reload(module)

erlaubt:

• Bot updaten ohne Disconnect

Production-Architektur (finales Bild)

IRC Server
│
Async IRC Client
│
┌───────────▼───────────┐
│ Event Dispatcher       │
└───────┬───────┬───────┘
│       │
Plugin System   Logger
│
Thread Pool (optional heavy tasks)

Ein echter IRC-Bot ist kein Skript, sondern:

Event-driven async system + Plugin Architektur + Resilience Layer