• some sort of persistence (a “bouncer” or the always-connected server)
• use with some sort of IRC client in Emacs
• some sort of reasonable mobile phone client

It ended up longer than I intended.

tldr

• Using some of the more IRCv3 tools, particularly the cluster of things by Simon Ser and co (soju, goguma, gamja - see below) makes for a much better IRC experience, and easily supports synchronised access across multiple devices (e.g., desktop, laptops, mobile).
  • soju provides a very capable bouncer
  • goguma provides an excellent mobile client
  • gamja is a very user-friendly web-client front-end
  • and these three things can complement each other in a complete IRC setup system
• we can make such a soju-based set-up work well with Emacs IRC clients
• soju and gamja can be self-hosted; but there are also two paid/hosted instances currently available:
  • SourceHut’s chat.sr.ht (on a fork of soju with a different feature-set)
  • IRC Today’s service (I think closer to mainline soju, but not certain)
• we can leverage some of the IRCv3 functions nicely in Emacs

The most useful bits here may be notes on how to set up clients to work with SourceHut’s chat.sr.ht, particularly Goguma and Emacs/ERC, and some of the cool features of IRCv3 things [modernising IRC], like the soju bouncer (which is used by chat.sr.ht), for which see the section below “Smooth & Modern IRC Implementation & Practice (mobile, Emacs)", which you might jump to if you don’t want to read a bunch of preamble.

History, theory, background

Pre-history: wee chats in musl pies

Long ago now I spent a while setting up a RaspberryPi 3b (running musl flavoured Void Linux) as a Weechat Server/Bouncer in order to make using IRC less painful. This involved a lot of steps, including setting up a NoIP script and SSL certs with Let’s Encrypt, and setting up scripts to auto-fetch new certs. But once up, it worked well (unless my home internet went out), and Weechat had a nice mobile app, so I could connect both on desktop/laptop with an Emacs IRC client and also had a pocket connection via my mobile phone ¹. This gave me a persistent connection and log history and all that.

Then I started using Matrix (=a modern, but heavy, “IRC replacement”, itself theoretically a Slack, Discord, &c. competitor) more, (in part) since some projects have chosen it as a more modern/capable alternative to IRC, and, soon after, it was the case that most of the IRC rooms I was in were bridged to Matrix anyway. And then it seemed perhaps more convenient just to access everything in one place, since some things were only Matrix and not on IRC, it made sense for that to be Matrix.

And then the Matrix bridges mostly shut down.

Path of the prodIRCal son

I toyed off and on with getting re-set up on IRC, but there has been a lot of other things going on in life, and I didn’t feel like trying to set up my rpi mini-server IRC bouncer again.

I tried some other hosted IRC bouncer services. But some of these wouldn’t let me connect with on a VPN.

I found one good free (as in freedom and free as in no paisa) ZNC bouncer service, which is FreeIRC.org ²

The ZNC bouncer worked fine on Emacs (with ERC; I’ve gone back and forth between ERC and Circe, but this time I was trying ERC again).³ And I eventually figured out how to connect to multiple networks through the ZNC bouncer.

But the best thing I could find on mobile was the Revolution IRC client, and, while it’s a nice enough front-end, it struggled with maintaining a connection to the ZNC bouncer I was using. (I asked about this in an IRC room, and the general consensus was that mobile’s just not a good place to try to do IRC, but I remembered that via the Weechat android app or through Glowing Bear I’d had a good mobile IRC experience years ago.)

IRCv3, and other Korean tubers

I also came across another IRC mobile app, Goguma, but couldn’t get it work. But, frustrated with the situation, I wanted to see if, assuming I could somehow get it work, Goguma might be a better mobile solution.⁴

I ultimately ended up stumbling across an interesting lobste.rs discussion of Goguma which pointed to it being part of a set of IRCv3-aware software, including an IRC bouncer soju, which a number of the commenters on the lobste.rs thread comparing the experience favourably against using ZNC.

A cluster of IRCv3 things:⁵

• Goguma (Korean 고구마 goguma “sweet potato”): IRC mobile client written in Flutter by Simon Ser
• Gamja (Korean 감자 gamja “potato”): simple IRC web client written in Javascript by Simon Ser
• Soju (Korean 소주 soju “a distilled alcoholic beverage”): IRC bouncer written in Go by Simon Ser
• Senpai (Japanese 先輩 sèńpáí “senior in social standing or level of education/skill; an elder”): a modern terminal IRC written in Go, started by ‘taiite', who handed development over to ‘delthas'.
• Ergo (a play on ergonomic [and “ergonomadic"] and Go(lang), so I suppose ultimately from Ancient Greek ἔργον érgon “work”, but not sure that’s relevant): a modern IRC server written in Go [Jeremy Latt, Daniel Oaks, Shivaram Lingamneni] implementing bleeding-edge IRCv3 features/support

The first three things are the most relevant for us (well, me). Ergo sounds great, but I’m not running an IRC server myself at the moment; and I’ve got a whole wealth of choices of Emacs IRC clients if I’m on desktop/laptop, so Senpai doesn’t seem relevant either for my use case.

Trains, Wayland, and Things that Go

The first three of the IRCv3-looking things are all by Simon Ser, who was lately at Drew DeVault‘s SourceHut, but seems to have left sometime in 2024⁶ and now works at Open Source Railway Designer (something to do with making tools for railway infrastructure simulation, which sounds quite cool: open source trains). Ser obviously works a good bit on IRC-related software, and also a lot of things in Go, and has been involved with Wayland-related projected (taking over maintainership of Sway (a Wayland window manager) and wlroots (Wayland general purpose compositor underlying Sway and other things) from DeVault some years back).

Here’s Thomas Flament & Simon Ser talking about IRCv3 and soju, senpai, gamja, goguma at FOSDEM ‘25 in Brussels:

Chatting on IRC in 2025: grandpa, what’s up? [video link with captions]

In any case, one of the paid-only features that SourceHut offers is via chat.sr.ht, an IRC bouncer, which is running on a fork of soju, with a web-client based on gamja.

As far as I can tell, Sourcehut’s servers are now (all? mainly?) in Amsterdam.⁷

chat.sr.ht isn’t the only hosted IRC bouncer service which runs some version of the soju bouncer, there is also IRC Today [discussed also on lobste.rs], which is hosted in Paris on Scaleway servers.⁸

So, there are at least two apparently EU-based hosted “IRCv3-forward” bouncers.

Smooth & Modern IRC Implementation & Practice (mobile, Emacs)

How to manage to drink rice liquor in a hut: preliminaries

In any case, I signed up for the SourceHut offering at chat.sr.ht, which uses their fork of soju.

Here’s what I did to get it set up for mobile and in Emacs (it seemed worth documenting, in what was meant to be a short post….):

The main things one needs to know are in the chat.sr.hut ‘manpages’, especially the ‘quickstart guide’. But here are a few more notes for specific set-up on Goguma and Emacs.

The first thing one needs to do for any “third-party” client (this includes Goguma or any Emacs IRC client) is generate an OAuth 2.0 personal access token in your SourceHut account. This will be effectively your “password” (with your SourceHut login name as your username).

Nb: on mobile, you have to be careful to actually manage to copy the entire token with “Select all” or the like - I was stuck for a long time not being able to make Goguma work because I’d not managed to copy the entire token, and this wasn’t at all obvious in a mobile browser. On desktop, it’s not an issue.

Goguma (mobile): One potato, two potato, sweet potato

For Goguma, you’re just going to put in:

• Server: chat.sr.ht
• Nickname: <your SourceHut username>
• Password: <an OAuth2.0 token you generated as above>

And you’re in. And here’s what it looks like:

And there’s a setting in Goguma (“Compact message list”) to make it look less like a mobile messaging app and just have plain text if you prefer that:

And you can have Goguma show you notifications if someone mentions your nick. Here is an example showing on a Pebble watch:

(IRC on one’s wrist; it truly is 2025.)

Emacs machines and authority tokens: what to put in your authinfo.gpg and init.el

In your ~/.authinfo.gpg file, add a line like this (with <>‘ed items to be replaced fully; don’t actually include any <>'s here or above or elsewhere; where "my-sourcehut-id" is your actual sourcehut login id in quotes):

machine chat.sr.ht login "my-sourcehut-id" password "<one of your OAuth 2.0 tokens generated at SourceHut meta>"

And then in your ~.emacs.d/init.el, assuming you’re using ERC and have that configured otherwise to your liking, make a user-function for each actual IRC server you want to connect with via chat.sr.ht/soju, like this (assuming your user-id is "my-sourcehut-id": replace appropriately— and you might have different :nick's (“nicknames” ≈ user-handles/user-names/identities) on different servers, of course, so adjust those as well; but your :username is going to be consistently your SourceHut username followed by “/<the-particular-irc-server-address>"):

;; just so we don't have to type it each time, a wrapping `let',
;; and so after this our `server', `port', & `passwd' will be thus defined
;; (you could do `:nick' like this too if it's the same everywhere)
(let ((server "chat.sr.ht")
      (port 6697)
      (passwd
       (cadr
        (auth-source-user-and-password "chat.sr.ht" "my-sourcehut-id"))))
  ;; `auth-source-user-and-password' returns a list of `login' and `password'
  ;; from your .authinfo.gpg; but we just need the second, so `cadr' (= return
  ;; the `car' of the `cdr'), because since the list is going to be something
  ;; like `(mylogin mypassword)', will give us just the atomic `mypassword',
  ;; which is what we want [because the `cdr' of `(mylogin mypassword)' will be
  ;; `(mypassword)' and the `car' of `(mypassword)' will be just `mypassword'].)

  (defun erc-libera ()
    "Connect to Libera.Chat IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc.libera.chat"
     :password passwd))

  (defun erc-oftc ()
    "Connect to OFTC IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc.oftc.net"
     :password passwd))

  (defun erc-ircnow ()
    "Connect to IRCNow IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc6.ircnow.org"
     :password passwd))

  (defun erc-ergo ()
    "Connect to IRCv3-forward Ergo IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc.ergo.chat"
     :password passwd)))

Here we’re making connections for Libera, OFTC, IRCNow, and Ergo, the IRCv3-forward server implemented in Go we mentioned above.⁹

But you can add lots of different servers to your bouncer, and both in Goguma and Emacs/ERC (just make a new erc-<server> function as above), you’ll just be able to get to all of the different rooms in one place and don’t necessary need to worry about which server a particular thing is on after getting it set up.

And then you can make a “connect to all the things function” like this:

(defun erc-connect-all ()
  "Connect to all IRC servers above."
  (interactive)
  ;; we're just calling all of the functions we defined above here:
  (erc-libera)
  (erc-oftc)
  (erc-ircnow)
  (erc-ergo))

And what it looks like (well, it looks like however you’ve configured ERC or whatever Emacs IRC client you’re using, but, in case you want to see a possible way it could look):

If you get knocked offline momentarily, ERC will try to reconnect to the bouncer. If you are knocked off or close Emacs for a while, you might want to catch up on what you missed recently. And there’s a nice IRCv3 feature implemented in soju (and in chat.sr.ht) for this, as discussed in the next section.

Leveraging IRCv3 features in Emacs

We can also do another convenient thing for our Emacs IRC configuration now. IRCv3 defines a “chathistory” extension, as an easy way of retrieving earlier IRC room content. This doesn’t work most places, but it works on any bouncers based on soju (see notes below), the syntax being /quote CHATHISTORY LATEST <channelname> * <number-of-lines-to-fetch>.

We can make this more user-friendly in Emacs with something like this, an interactive command that fetches history for whatever IRC room it’s called in (a 100 lines by default; prefix C-u to enter a different number):

(defun erc-chatsrht-give-me-more-irc-history ()
  "Get more history for current IRC buffer (IRCv3 only).

Defaults to 100 lines of history; when C-u prefixed, asks user for
number of lines to fetch.

If using an IRCv3 capable server/bouncer (like chat.sr.ht), fetch the
chat history via the IRCv3 chathistory extension. (Currently, only
soju-based servers implement this feature; see:
https://ircv3.net/software/clients)

For more on chathistory, see:
 - https://man.sr.ht/chat.sr.ht/bouncer-usage.md#chat-history-logs
 - https://ircv3.net/specs/extensions/chathistory
 - https://soju.im/doc/soju.1.html"
  (interactive)
  (if (not (member
            (with-current-buffer (current-buffer)
              major-mode)
            '(erc-mode
              circe-mode
              rcirc-mode)))
      (message "not an IRC buffer; ignoring")
    (let ((lines 100)
          (channel (buffer-name)))
      (when current-prefix-arg
        (progn
          (setq lines
                (read-number (format "How many lines to fetch: ") lines))))
      (erc-send-input
       (concat "/quote CHATHISTORY LATEST " channel " * " (number-to-string lines))
       t))))

Then you can just call erc-chatsrht-give-me-more-irc-history in an IRC buffer (you might find a convenient keybinding for it) to get prior IRC chat in that buffer.

This sort of thing makes Emacs a very pleasant environment to manage IRC in.

Now, for actually adding servers to your chat.sr.ht bouncer in the first place, you might try out the gamja web client (see below).

Inline images and files in Goguma and Emacs

Oh. Gamja (as least as implemented by chat.sr.ht) doesn’t seem to do it, but Goguma fetches image links and displays a preview:

[Note: chat.sr.ht’s soju fork doesn’t currently offer direct file-upload and is perhaps unlikely to, but this seems to be implemented in upstream soju and maybe on IRC Today.]

Additional note: Goguma doesn’t do this by default; you need to go into the main “Settings” menu and enable “Display link previews”. (I also have “Send & display typing indicators” turned on here.)

And you can make ERC do similarly, with respect to fetching posted image links, with the erc-image package from MELPA. I have a use-package definition like this:

(use-package erc-image
  :ensure t
  :after erc
  :config
  (setq erc-image-inline-rescale 300) ; maybe set bigger
  (add-to-list 'erc-modules 'image))

And then you’ll see something like this if you post an image link in ERC:

I’d like to figure out how one might better manage it, but — in terms of handling posting local files — there’s a (not-on-MELPA) package imgbb.el which will upload images in Emacs (when passed a file-path or interactively from a file-chooser) to ImgBB, and then put the link in the clipboard.¹⁰

[Note: For better or worse, erc-image will pull images from http as well as https addresses; while Goguma seems only to do the latter.]

Web-client: The sweetness of non-sweet potatoes on the web

The web interface for chat.sr.ht (at https://chat.sr.ht) is, again, based on gamja (“potato”) (discussed above) and gamja is a nice interface indeed.

And, for making your initial connections to different IRC servers, it may be easier just to use this web interface, especially if you’ve already got accounts set up on any of the servers, as for most of them you’ll be able to enter your username and password and so on in the “Add server” interface and not have to do all of the /msg NickServ .... stuff one usually does. (If you don’t have an account already, you’ll have to register in someway, maybe by messaging Nick).

Looks like this:

In fact, even for signing in/up on a brand new server, at least on some servers, gamja lets you click on “login” or “register” and pulls up a pop-up box to fill in password, email, &c. So it’s quite convenient (and you may not have to message Nick manually).

Wrap-up & evaluation

There are interesting IRC things still going on, both in terms of active IRC communities (though this varies; #emacs is quite active, #dwarffortress isn’t; Discord has eaten into some spaces), and innovations in IRC technologies and tools.

I’m not sure what the best thing is terms of choice of a soju/gajma ecosystem. chat.sr.ht seems to be the cheapest hosted option; IRC Today is more expensive but may currently be more featureful. SourceHut has had trouble with being DDOS’ed/going off-line (see, e.g., SourceHut network outage post-mortem).

Self-hosted set-ups are another option, but are likely to be more fiddly/effort to run/maintain than a “professional” service. But here are a few links to descriptions of people’s self-hosted soju setups:

• self-hosting on Alpine Linux: Self-Hosting Soju
• self-hosting on OpenBSD: Setting up an IRC bouncer (soju) on OpenBSD · Hugo’s weblog
• more self-hosting on Alpine Linux: Self-Hosted IRC with Soju & Senpai | Isaac Ganoung’s Website
• self-hosting on IRCNow: IRCNow | Soju / Guide

Currently, chat.sr.ht is working well for me, even if it may be behind on some mainline soju features.

Appendix: etymologies

You probably don’t need to know any of this. It’s not going to help you log into Goguma or make your Emacs config work.

But the naming of a lot of the IRC things above is strange and I’m a linguist by trade and it’s hard for me to avoid paying a lot of attention to words and meanings of words and connections of words.

(While on the topic of mostly irrelevant things: I have some other-language interference (Hindi here) with the Korean names of some of the software discussed here. Specifically, gamja makes me think either गंजा ganjā “bald” or गाँजा gā̃jā “ganja, cannabis”; and soju keeps making me think of an elided version of सो जाऊं so jāū̃ “shall I go to sleep?” [“नहीं! आप आई॰आर॰सी॰ बाउंसर हैं, आपको सो नहीं जाना चाहिए! No! You’re an IRC bouncer: you should not go to sleep!"])

At any rate, here are, unasked for, etymological notes on the four IRCv3 things with Korean or Japanese names, largely sourced from Wiktionary, as indicated, with some connecting text:

Goguma

[mainly sourced from: https://en.wiktionary.org/wiki/%EA%B3%A0%EA%B5%AC%EB%A7%88]

Named apparently after Korean 고구마 goguma “sweet potato” (cp. the web client by the same team, gamja “potato”). First attested in the Mulmyeonggo (물명고 / 物名考), 1824, as Early Modern Korean 고금아 (Yale: kokuma), borrowed from Japanese 孝行芋 (kōkō imo), a term used in the Tsushima dialect. Some earlier attestations are known, but they are in the context of quoting the dialectal Japanese word, not in a Korean context.

There’s also apparently a recent “Internet slang” sense: “a plot development which frustrates the reader (e.g. the protagonist fails to achieve their goal)” [from c. 2012].

The Japanese word 孝行芋 (kōkō imo) from which Korean 고구마 goguma is borrowed is apparently 孝行 (kōkō) [? “dutiful”??] + 芋 (imo) from Old Japanese, attested in the Nihon Shoki of 720, referring to “edible tubers”. May be a shift from older form うも (umo), ultimately from Proto-Japonic *umo. Cognate with Okinawan 芋 (‘nmu). [see: https://en.wiktionary.org/wiki/%E5%AD%9D%E8%A1%8C%E8%8A%8B#Japanese https://en.wiktionary.org/wiki/%E8%8A%8B#Japanese ]

The Japanese word 芋 (imo) is connected to Chinese 芋 [Old *ɢʷas, Modern Mandarin yù ] “taro”.

Seemingly a phono-semantic compound (形聲 / 形声, OC *ɢʷa, *ɢʷas): semantic 艸 (“grass; plant”) + phonetic 于 (OC *ɢʷa) – “taro”.

Compare Proto-Hmong-Mien *wouH (“taro”), Burmese ဝ (wa., “elephant foot yam”), Tibetan གྲོ་མ (gro ma, “ Argentina anserina (syn. Potentilla anserina), a plant with small edible tubers”).

There are various theories on how all these words are related:

• Schuessler (2007) considers it to be an areal word, comparing it to the Hmong-Mien and Burmese words. Schuessler (2015) does not consider the Tibetan word to be cognate.

• Blench (2012) suggests that the Chinese word is borrowed from Proto-Hmong-Mien and that the Burmese word may be a late loan from Old Chinese.

• STEDT reconstructs Proto-Sino-Tibetan *g/s-rwa (“taro; yam; tuber”), whence the Tibetan word. This etymon is regarded as allofamically related this word and 薯 (OC *djas).

• Gong Hwang-cherng (2002) and Baxter and Sagart (2017) also suggest that this word is related to the Tibetan word.

  [on the Chinese, see: https://en.wiktionary.org/wiki/%E8%8A%8B]

Gamja

[sourced from: https://en.wiktionary.org/wiki/%EA%B0%90%EC%9E%90]

Seemingly named from Korean 감자 gamja “potato”, which is a nativisation of the Sino-Korean term 감저 (甘藷, gamjeo, “lesser yam (Dioscorea esculenta)”). First attested 1766 in Korea, then referring to the sweet potato (Ipomoea batatas). The word came to refer to both “potato” and “sweet potato” in the nineteenth century, and later lost its original meaning. (So gamja meant “sweet potato” first; but partially supplanted by goguma.)

With 甘藷, gamjeo apparently borrowed from Early Modern Korean 감져 (kamcye), itself from 甘藷 [https://en.wiktionary.org/wiki/%E7%94%98%E8%97%B7].

[There’s also homophonous verbal form: 감자 (gamja) (plain hortative of 감다)

1. let’s close (our eyes)

2. let’s wash

   which is presumably unrelated.]

Soju

[source: https://en.wikipedia.org/wiki/Soju]

Seemingly named for Korean Soju (소주; 燒酒), which means “burned liquor”: with the first syllable, so (소; 燒; “burn”), referring to the heat of distillation and the second syllable, ju (주; 酒), meaning “alcoholic drink”. Etymological dictionaries record that China’s shaozhou (shāojiǔ, 烧酒), Japan’s shochu (shōchū, 焼酎), and Korea’s soju (soju, 燒酒) have the same etymology. [A Wikipedian has here added a note about unreliable sources(?).]

Another name for soju is noju (노주; 露酒; “dew liquor”), with its first syllable, no/ro (노/로; 露; “dew”), likening the droplets of the collected alcohol during the distilling process to dewdrops.

The origin of soju dates back to 13th-century Goryeo. The Yuan Mongols [the imperial dynasty of China founded by Kublai Khan, grandson of Genghis Khan] acquired the technique of distilling arak from the Persians during their invasions of the Levant, Anatolia, and Persia, and in turn introduced it to the Korean Peninsula during the Mongol invasions of Korea (1231–1259). Distilleries were set up around the city of Gaegyeong, the then-capital (current Kaesong). In the areas surrounding Kaesong, soju is still called arak-ju (아락주). Andong soju, the direct root of modern South Korean soju varieties, started as the home-brewed liquor developed in the city of Andong, where the Yuan Mongols’ logistics base was located during this era.

Senpai

[source: https://en.wiktionary.org/wiki/%E5%85%88%E8%BC%A9#Japanese]

Obviously named for Japanese 先輩 senpai “senior/superior in social standing or education or skill; an elder” (the homepage has a tagline “Your everyday IRC student” and also “Welcome home, desune~” and also a smiling anime-ish cat-ish logo).

The Japanese word was borrowed from the Middle Chinese 先輩 (sen pwojH). A doublet of ソンベ (sonbe) [With Japanese sonbe being itself borrowed from Korean 선배(先輩) (seonbae), which means “(chiefly in Korean media) sunbae (upperclassman or senior, in the context of Korea)"].

Both ultimately from Chinese 先輩 [ xiānbèi ] “older generation; senior; elder; ancestor; predecessor”.

Lisp

• Common Lisp:
  • …

• Clojure: slack
  • Racket: slack