UTALK(1)

📦 version 1.0.2, in debian bookworm, ubuntu jammy, ubuntu noble, ubuntu resolute, ubuntu stonking

💬 UTALK(1) — General Commands Manual 💬

okay bestie, pull up a chair, we're doing utalk(1) and it's gonna be a whole journey 🫶 this is the manual page for utalk, and no cap, it's kind of a lot, but it's so worth it.

✨ NAME ✨

utalk — a UDP-based full screen talk program 💅

🌈 SYNOPSIS 🌈

utalk [options] user[@host][#tty]
utalk [options] !port@host
utalk [options] -s port
utalk [options] -c host port

🎀 OPTIONS 🎀

  • -s, --server — tells utalk to NOT go through the talk daemons to announce itself, and instead just… chill and wait for a connection on the port number you gave it. server era, periodt ✨
  • -c, --client — same vibe but opposite: don't use the talk daemons to announce yourself, just connect straight to the given port number on the given host. no daemon middleman, we're going direct 💅
  • -a, --announce-only — makes utalk pick a local port number for itself and send out an announce carrying that port number instead of your username. super useful when you wanna start a utalk session with a host that does have a talk daemon but yours lowkey doesn't 🫠
  • -7, --seven-bit — makes utalk convert every single character to 7-bit US-ASCII before it displays them. iconic move if your terminal isn't iso-8859-1 capable, ngl 😭
  • -8, --eight-bit — makes utalk show iso-8859-1 encoded characters on screen exactly as they arrive. as they were received, no edits, no filter 💖

🦋 ARGUMENTS 🦋

  • user@host[#tty] — this is who you're ringing 📞 the "user@host" part can be swapped out for an alias name that you defined in your ~/.utalkrc. and if you specify the tty, utalk will ask the talk daemon to ring that user on that particular tty, like, specifically. also: the username can have a '!' prefixed onto it, and utalk will just strip that bad boy off.
  • !port@host — this one tells utalk the port number to connect to, plus the host. it's giving "answering a utalk -a" energy 💫

💖 DESCRIPTION 💖

so utalk is a text-based chat program, in the same vein as talk and YTalk, BUT it uses a better protocol built on top of UDP for communication. the way that it does not require network packets to arrive in sequence in order to display them?? game changer. it means utalk can be used over unreliable links, where a TCP/IP connection like a telnet or a talk would be way too slow to actually be usable. no cap 🙌

on top of all that, utalk supports full editing of previously typed text, scrollback, keyboard bindings, and aliases. obsessed.

⚠️ important: utalk is incompatible with every other talk program out there, because it uses a completely different protocol. and unfortunately — the way that this is literally out of our hands — the text "respond with: talk" is hard-coded into the talk daemon and cannot be set by the client. 💀

to avoid confusion, utalk's talk requests send the username prefixed with a '!', which must be understood as respond with utalk.

👑 DISPLAY 👑

same as in talk and YTalk, the utalk screen is split into two separate scrolling areas (a.k.a. windows): the one at the top is for you, and the one at the bottom is for the other connected user 🫶

at any given time, one of these windows is active. and each scrolling area has a status line at the top of it, showing the name of the client plus these flags:

  • [m] — this flag is always present on the top window, because it's your own window. from your point of view, it literally means it's "my" window 💅
  • [o] — this flag means your own window is in overwrite mode.
  • [i] — this flag means your own window is in insert mode.
  • [*] — this flag means the window is active and in read-write mode. this is the normal mode for your own window; in this mode you can type and edit, and when you move your cursor and/or scroll back, the other connected user can see your cursor movement too 👀
  • [R] — this flag means the window is active and in read-only mode. this is the only way a window other than yours can be active (like, you can't type text into someone else's window, obviously). setting your own window into read-only mode lets you scroll back through what you typed without the other user seeing you doing it 🤫
  • [n] — means the window is not yet connected; the user hasn't responded yet. the waiting era 😭
  • [c] — means the window is connected. slay ✅
  • [b] — means the window is connected, BUT no data has been received for a while — and that includes even the control data that utalk sends periodically. so the connection might be broken, or the client on the other side might have crashed 💀 utalk will not interrupt a connection because of this; it's up to you to stop it after a while if it doesn't come back. so like, keep an eye on it bestie 🫠

✨ EDITING ✨

okay so utalk's editing keys can be configured to emulate either vi or emacs, in a limited way. By default, utalk is in emacs mode. 💅

utalk keeps a table of bindings for each of three modes: emacs mode, vi command mode, and vi insert mode. These tables are initialized to suitable defaults, and you can add bindings with the bind command in your ~/.utalkrc file. 🎀

The following is a list of all key commands and their default bindings in emacs mode, vi command mode, and vi insert/replace mode respectively. 👑

  • self-insert — emacs: (printable chars) · vi command: (unbound) · vi insert/replace: (printable chars)

In overwrite mode (replace in vi mode) the keypress gets inserted at the current cursor position, the character at this position is replaced by the new one, and the cursor moves forward one step.

In insert mode the key gets inserted as well at the current cursor position but the rest of the line (if any) is moved one step to the right.

  • toggle-overwrite — emacs: (ESC [2~) · vi command: (unbound) · vi insert/replace: (unbound)

Change between overwrite and insert modes. In most systems the sequence ESC [2~ is mapped to the insert key. ✨

  • insert-in-place — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (unbound)

The keypress gets inserted at the current cursor position, and the cursor does not move. 💅

  • quote-char — emacs: (^Q) · vi command: (unbound) · vi insert/replace: (^V)

Insert the following key literally. 🎀

  • tab — emacs: (^I) · vi command: (unbound) · vi insert/replace: (^I)

Moves the cursor to the next tab stop. ✨

  • new-line — emacs: (^M, ^J) · vi command: (^M, ^J) · vi insert/replace: (^M, ^J)

Moves the cursor to the first position on the next line, possibly creating the line. In most systems the control codes ^M or ^J are mapped to the enter key. 👑

  • delete — emacs: (^D, ESC [3~) · vi command: (x) · vi insert/replace: (unbound)

Deletes the character under the cursor. In most systems the sequence ESC [3~ is mapped to the delete key. 💀

  • delete-end-of-line — emacs: (^K) · vi command: (D, d$) · vi insert/replace: (unbound)

Deletes from the cursor to the end of the line. ✂️

  • delete-beginning-of-line — emacs: (unbound) · vi command: (d0, d^) · vi insert/replace: (unbound)

Deletes from the beginning of the line to the cursor. 🫶

  • delete-line — emacs: (^U) · vi command: (dd) · vi insert/replace: (^U)

Deletes the current line. 💅

  • delete-word — emacs: (ESC d) · vi command: (dw, dW) · vi insert/replace: (unbound)

Deletes to the beginning of the next word. 🌸

  • delete-end-of-word — emacs: (unbound) · vi command: (de) · vi insert/replace: (unbound)

Deletes to the end of the current word. ✨

  • backspace — emacs: (^H, DEL) · vi command: (X) · vi insert/replace: (^H, DEL)

Moves back the cursor one position, erasing the character in that position, the rest of the line (if any) is moved one step to the left. In most systems the control codes ^H or DEL are mapped to the backspace key. 🎀

  • backspace-word — emacs: (^W) · vi command: (unbound) · vi insert/replace: (^W)

Backspaces over one word. 😌

  • backward — emacs: (^B, ESC [D) · vi command: (h, [D) · vi insert/replace: (unbound)

Moves backward one position. In most systems the sequence ESC [D is mapped to the left arrow key. ⬅️

  • forward — emacs: (^F, ESC [C) · vi command: (l, [C) · vi insert/replace: (unbound)

Moves forward one position. In most systems the sequence ESC [C is mapped to the right arrow key. ➡️

  • backward-word — emacs: (ESC b) · vi command: (b, B) · vi insert/replace: (unbound)

Moves backward one word. 🦋

  • forward-word — emacs: (ESC f) · vi command: (w, W) · vi insert/replace: (unbound)

Moves forward one word. 🦋

  • end-of-word — emacs: (unbound) · vi command: (e) · vi insert/replace: (unbound)

Moves to the end of the current word. ✨

  • beginning-of-line — emacs: (^A, ESC [7~) · vi command: (0, ^) · vi insert/replace: (unbound)

Moves to the beginning of the current line. In most systems the sequence ESC [7~ is mapped to the home key. 🏠

  • end-of-line — emacs: (^E, ESC [8~) · vi command: ($) · vi insert/replace: (unbound)

Moves to the end of the current line. In most systems the sequence ESC [8~ is mapped to the end key. 🔚

  • nop — emacs: (unbound) · vi command: (ESC) · vi insert/replace: (unbound)

Does nothing. Literally nothing. It's giving nop core. 💀

  • beep — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (unbound)

Beeps the terminal (does not send a beep across to the other clients). 🔔

  • up — emacs: (^P, ESC [A) · vi command: (k, [A) · vi insert/replace: (unbound)

Moves the cursor up one line. In most systems the sequence ESC [A is mapped to the up arrow key. ⬆️

  • down — emacs: (^N, ESC [B) · vi command: (j, [B) · vi insert/replace: (unbound)

Moves the cursor down one line. In most systems the sequence ESC [B is mapped to the down arrow key. ⬇️

  • up-page — emacs: (ESC v, ESC [5~) · vi command: (^B) · vi insert/replace: (unbound)

Moves the cursor up one page if the screen is in read/write mode, and scrolls up by one page if it is in read-only mode. In most systems the sequence ESC [5~ is mapped to the page up key. 📄

  • down-page — emacs: (^V, ESC [6~) · vi command: (^F) · vi insert/replace: (unbound)

Moves the cursor down one page if the screen is in read/write mode, and scrolls down by one page if it is in read-only mode. In most systems the sequence ESC [6~ is mapped to the page down key. 📄

  • up-half-page — emacs: (unbound) · vi command: (^U) · vi insert/replace: (unbound)

Moves the cursor up half a page if the screen is in read/write mode, and scrolls up by half a page if it is in read-only mode. 💅

  • down-half-page — emacs: (unbound) · vi command: (^D) · vi insert/replace: (unbound)

Moves the cursor down half a page if the screen is in read/write mode, and scrolls down by half a page if it is in read-only mode. ✨

  • top-of-screen — emacs: (unbound) · vi command: (H) · vi insert/replace: (unbound)

Moves the cursor to the first line of the current visible screen. 👑

  • middle-of-screen — emacs: (unbound) · vi command: (M) · vi insert/replace: (unbound)

Moves the cursor to the middle of the screen. Main character energy. 💅

  • bottom-of-screen — emacs: (unbound) · vi command: (L) · vi insert/replace: (unbound)

Moves the cursor to the last line of the current visible screen. 🌸

  • top-or-up-page — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (unbound)

Moves the cursor to the top of the screen if it's not there, or scrolls up by one page if it is. 🫶

  • bottom-or-down-page — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (unbound)

Moves the cursor to the bottom of the screen if it's not there, or scrolls down by one page if it is. 🫶

  • vi-goto-line — emacs: (unbound) · vi command: (G) · vi insert/replace: (unbound)

Moves the cursor to the line number entered as a prefix, if any; otherwise moves to the last line of the buffer. ✨

  • redisplay — emacs: (^L) · vi command: (^L) · vi insert/replace: (^L)

Redraws the screen. Refresh, bestie. 💅

  • resynch — emacs: (^R) · vi command: (^R) · vi insert/replace: (^R)

Requests immediate transmission of all missing packets. Get those packets, queen. 👑

  • next-window — emacs: (^X b, ^X o, ^G) · vi command: (g) · vi insert/replace: (unbound)

Cycles the active window between your window in read/write mode, your window in read-only mode, and each of the other windows. 🪟

  • set-topic — emacs: (^T) · vi command: (^T) · vi insert/replace: (unbound)

Prompts the user for a topic, which will be displayed at the top of the screen for all users. 💬

  • vi-insert-mode — emacs: (unbound) · vi command: (i) · vi insert/replace: (unbound)

Sets vi insert mode. ✨

  • vi-replace-mode — emacs: (unbound) · vi command: (R) · vi insert/replace: (unbound)

Sets vi replace (overwrite) mode. 💅

  • vi-command-mode — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (unbound)

Sets vi command mode. 👑

  • emacs-mode — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (unbound)

Sets emacs mode. 🌸

  • quit — emacs: (^X c, ^C) · vi command: (ZZ) · vi insert/replace: (unbound)

Quits utalk. 👋

  • vi-escape — emacs: (unbound) · vi command: (unbound) · vi insert/replace: (ESC)

Sets vi command mode and moves the cursor one position to the left. 🎀

  • vi-add — emacs: (unbound) · vi command: (a) · vi insert/replace: (unbound)

Moves the cursor one position to the right and sets vi insert mode. ➡️✨

  • vi-add-at-end-of-line — emacs: (unbound) · vi command: (A) · vi insert/replace: (unbound)

Moves the cursor to the end of the current line and sets vi insert mode. 🔚✨

  • vi-insert-at-beginning-of-line — emacs: (unbound) · vi command: (I) · vi insert/replace: (unbound)

Moves the cursor to the beginning of the current line and sets vi insert mode. 🏠✨

  • vi-open — emacs: (unbound) · vi command: (o) · vi insert/replace: (unbound)

Moves the cursor to the beginning of the next line and sets vi insert mode. 📄✨

  • vi-open-above — emacs: (unbound) · vi command: (O) · vi insert/replace: (unbound)

Moves the cursor to the beginning of the previous line and sets vi insert mode. 📄✨

  • vi-replace-char — emacs: (unbound) · vi command: (r) · vi insert/replace: (unbound)

Replaces the char under the cursor with the following key. 🔄

  • vi-find-char — emacs: (unbound) · vi command: (f) · vi insert/replace: (unbound)

Moves the cursor to the next occurrence of the following key on the same line. 🔍

  • vi-reverse-find-char — emacs: (unbound) · vi command: (F) · vi insert/replace: (unbound)

Moves the cursor to the previous occurrence of the following key on the same line. 🔍

  • vi-till-char — emacs: (unbound) · vi command: (t) · vi insert/replace: (unbound)

Moves the cursor to one position before the next occurrence of the following key on the same line. 🎯

  • vi-reverse-till-char — emacs: (unbound) · vi command: (T) · vi insert/replace: (unbound)

Moves the cursor to one position after the previous occurrence of the following key on the same line. 🎯

  • vi-repeat-find — emacs: (unbound) · vi command: (;) · vi insert/replace: (unbound)

Repeats the previous find or till command. 🔁

  • vi-reverse-repeat-find — emacs: (unbound) · vi command: (,) · vi insert/replace: (unbound)

Repeats the previous find or till command, reversing the direction. 🔁

  • vi-delete-find-char — emacs: (unbound) · vi command: (df) · vi insert/replace: (unbound)

Deletes all characters between the current position and the next occurrence of the following key on the same line, both included. ✂️

  • vi-delete-reverse-find-char — emacs: (unbound) · vi command: (dF) · vi insert/replace: (unbound)

Deletes all characters between the current position and the previous occurrence of the following key on the same line, both included. ✂️

  • vi-delete-till-char — emacs: (unbound) · vi command: (dt) · vi insert/replace: (unbound)

Deletes all characters between the current position and the next occurrence of the following key on the same line, not including the latter. ✂️

  • vi-delete-reverse-till-char — emacs: (unbound) · vi command: (dF) · vi insert/replace: (unbound)

Deletes all characters between the current position and the previous occurrence of the following key on the same line, not including the latter. ✂️

  • vi-flip-case — emacs: (unbound) · vi command: (~) · vi insert/replace: (unbound)

Flip the case of the character under the cursor. ✨

🎀 CONFIGURATION 🎀

okay so you can set a whole bunch of stuff for utalk in a config file, and that file lives in your home directory and it's called .utalkrc. bestie, it's giving ~personalized~. 💅

The valid commands are, and I'm listing them exactly, no crumbs:

emacs-mode
vi-mode
bind key function
bind! key function
alias alias value
set setting on|off

✨ Settings ✨

These are the settings you can poke at. every single one, we're not skipping any:

  • beep — decides whether utalk lets beeps through or silences them. (the beeps. the little guys. you choose.)
  • word-wrap, wordwrap, ww — turns word-wrap on or off. heads up: it only kicks in at the end of the last line in the buffer.
  • eight-bit, eightbit, eb — lets eight-bit iso-latin-1 characters through, or maps them to US-ASCII. pick a lane.
  • meta-esc, metaesc, me — maps keys with the high bit set to ESC followed by key, or just lets them through. ngl this one only affects emacs-mode.
  • overwrite — sets the initial overwrite mode to on, or off for insert mode, and you can change it later (usually with the insert key). lowkey this setting only affects emacs-mode, because in vi-mode the mode is set explicitly with the "i" and "R" commands. periodt.

also, quick glossary vibes:

  • "toggle" and "se" are synonyms for "set".
  • "bindkey" and "bindkey!" are synonyms for "bind" and "bind!", respectively.

and in settings, the "on" and "off" arguments are optional — "on" is assumed by default, unless the setting's name is prefixed with "no". sneaky but iconic.

Bindings apply to the current mode. so if you wanna change bindings in vi mode, put a "vi-mode" first, then your "bind"s and "bind!"s after it. and in emacs mode, "bind" and "bind!" are synonymous. 🫶

In a binding, the key has to be a character or a sequence of characters, and you do not separate them with any spaces. The following sequences are recognized to specify characters:

  • ^char, C-char — Control-char
  • M-char — Meta-char
  • \e — ESC
  • \t — Tab
  • \r — Carriage return (^M)
  • \n — Newline (^J)
  • \xhex code — Ascii code given in hex
  • char — That char, taken literally
🚨 okay bestie listen: you shouldn't bind functions to M-key combinations in emacs mode. use ESC key combinations instead, and turn meta-esc on if you want to use your Meta key like in emacs. iykyk.

🌸 Aliases 🌸

You can make aliases for addresses of people to ring, in either of 3 forms:

  • alias aliasname@ username@ — Replaces aliasname@host with username@host for every host. the '@' at the end of username@ is not required.
  • alias @aliashost @realhost — Replaces user@aliashost with user@realhost for every user. the '@' at the beginning of @realhost is not required.
  • alias aliasname user@host — Replaces aliasname with user@host.

💜 COPYING 💜

utalk is free software. You can redistribute it and/or modify it under the GNU General Public License as published by the Free Software Foundation. See the file LICENSE for details. (slay, and also legally binding, so like, read it fr fr 💖)

🦋 SEE ALSO 🦋

talk(1), ytalk(1), talkd(8), mesg(1)

🍓 FILES 🍓

  • ~/.utalkrc — configuration file

💀 BUGS 💀

not me having to tell you the flaws, but here we are:

  • Currently the wordwarp function only works in overwrite mode, not in insert mode. (yes, it's spelled wordwarp up in here, that's just how it is 💅) and if the users have a different terminal width, the wordwrap is only done correctly in the local "my" window.
  • The vi and emacs emulations are relatively primitive.
  • There is an embedded help function but is not completed. 😭

👑 AUTHOR 👑

utalk was written by Roger Espel Llima <roger.espel.llima at pobox.com>. Version 1.0.2 was released by E. Bosch <presidev at gmail.com>.

and that's the whole page, bestie!! 🌈✨ this manual page is from utalk version 1.0.2 — the page itself is credited to Roger Espel Llima and it's dated Dec 27, 2020, filed under UTALK(1). go forth and talk, you absolute main character 🎀🫶💖

📦 where this page comes from