Messaging¶
The Messages tab: LXMF messages with other Reticulum users (Sideband, MeshChat, NomadNet and other LXMF clients).
- Conversations: a conversation per peer, with unread counts in the
list and the sidebar. Start one by address (
n), from the Network tab, or from anlxmf@link on a page. - Pinning: a pinned conversation stays at the top of the list, newest
pinned first.
*pins or unpins the open one in the TUI; in the web UI, it's the 📌 button above the conversation. - Marking all read:
Rin the TUI's Messages tab, or ✓ All read above the web UI's conversations (shown while anything is unread). - Drafts: what you write (and attach) stays with its conversation. Opening another one doesn't carry it over, and coming back brings it back. A message that fails to send goes back to the conversation it was for. In the web UI, drafts also outlive reloading the page (which phones do to pages left in the background) and restarting rettui: their text, and what they reply to, are kept in that browser. Files attached aren't.
- Messages in a row: in the TUI, messages from the same side sent within five minutes of each other show under one heading, without a gap, as chat apps do. Each starts a new heading again when its state, its signal or a reply sets it apart.
- Message states: your messages show sending…, ✓ (delivered), ✓ via propagation node, cancelled, or failed with the reason. While one is being sent, sending… says how it's going: finding a path, working out its stamp, connecting, how much of a large one has gone (42%), or, for one small enough for a single packet, waiting for delivery.
- Cancelling a send:
con a picked message in the TUI, or ■ Cancel beside it in the web UI, stops sending it, as NomadNet and Sideband let you. It shows as cancelled, isn't sent again when they announce, and can be sent again by hand. A message that went in one packet is on its way and can't be called back, so it can't be cancelled then. - Delivery modes:
- Auto (default): tries direct delivery first. If that fails, it hands the message to your propagation node.
- Direct: delivers over a Link and waits for the recipient's proof.
- Propagated: always goes through the propagation node.
- Paper: isn't sent. It's written as a paper message to pass on some other way.
- Each conversation keeps its own mode:
d(orCtrl-Pwhile writing) in the TUI, the menu beside Send in the web UI. Paper is for one message; the next goes their usual way again. The contact card shows a mode other than auto. - Stamps and ratchets: if the recipient's announce asks for a stamp, rettui generates it (or uses a ticket they gave you). It also generates the propagation node's stamp, and encrypts to the recipient's ratchet when one is known. Your own announces carry a ratchet too, so messages to you have forward secrecy (see Data and Storage). To ask for stamps yourself, see Blocking and spam.
- Propagation nodes: the ones you hear are listed in the Network tab.
Pick one with
p. You can also host one, or let rettui pick one (below). rettui syncs everysync_interval_mins(120, two hours, by default; 0 for never; Sync every in Status) or whenever you pressS. Settings that still had the old default of 30 minutes move to two hours; an interval of your own stays. A sync identifies you to the node, downloads your messages, then tells the node to delete them. It downloads them 512 KB at a time, as many times as it takes, each lot cleared from the node as it arrives, so a slow link isn't held for long by one transfer. A message bigger than that (a node can be set to take them), within your Largest message limit, comes in a transfer of its own. While it runs, the Status tab (either UI) says how many of the messages waiting have come (3 of 10 downloaded).Sagain, or Stop sync in the web UI, stops it after the download it's on; what has come is kept. - Attachments:
- The first image goes in the LXMF image field, which Sideband and MeshChat show inline. Other files are sent as file attachments.
-
Pictures are made smaller before they're sent, as Sideband and MeshChat do. A photo straight from a phone is megabytes, which takes minutes over a radio link, if it gets there at all: propagation nodes usually take 256 KB at most. Send pictures at (Status,
picture_size) picks how small:- small: at most 480 pixels on the longest side, about 20–40 KB. For LoRa.
- medium (the default): 1024 pixels, about 100–200 KB.
- large: 2048 pixels, often over 500 KB, too big for most propagation nodes.
- original: as they are.
A picture is turned the way its camera noted and sent as a JPEG (a PNG if it's partly see-through). That leaves out its metadata, such as where a photo was taken. GIFs go as they are, since they may move, and so does a picture that wouldn't get smaller. The picture on your computer isn't changed: the smaller copy is saved in
uploads/(see Data and Storage), and goes when the message is deleted. While you write, a picture to be shrunk shows (smaller) in the TUI, and sent smaller in the web UI. - Received attachments are saved automatically, and images get an inline preview.oopens the newest attachment with your desktop's default app. - Many clients refuse direct transfers over about 1 MB, and rettui warns before sending that much. - Signatures: incoming messages are checked against the sender's key. If the key isn't known, rettui looks it up first (up to 10 s). Messages that still can't be checked are marked unverified. A message whose signature doesn't match its sender's known key was written by someone else: it's dropped, and the log says so (as Python LXMF does). A message from an unknown sender is shown for up to 10 seconds while the key is looked for, then verified or removed. A location or interface list in an unverified message isn't used, and when the table of known keys is full the key heard longest ago makes room (contacts' keys are always kept). - Peers who are offline: public keys from announces are kept, so you can write to a peer you heard earlier even while they're away. - Announces: rettui announces your LXMF address when it starts (unless you turn that off), on its own every so often, and whenever you pressA. Announce on its own (Status,announce_schedule) is: - random (the default): at a random time between Random: from and Random: to (announce_random_min_minsandannounce_random_max_mins, 60 and 360 minutes), picked again after each announce, as Sideband does, so announces don't fall in step with everyone else's; - fixed: every Fixed: every minutes (announce_interval_mins, 360); - off: only at start and when you announce.
All of them stay between one hour and six (more often, and public gateways hold your announces back). Settings from before this keep their choice: an interval of 0 is off, and one of your own (other than 360, the old default) is fixed. An announce only reaches those connected when it goes out, so when an interface comes online later (an entry point that connects late, or one interface discovery connects to), rettui announces again, as Sideband does. One that comes back within half an hour of an announce going out on it doesn't bring another: public gateways hold back destinations that announce too often. With announcing at start and on its own both off, it doesn't.
Picking a propagation node automatically¶
Pick propagation node automatically (ticked in the getting-started guide the first time it opens, with a warning under it; otherwise off unless you turn it on) picks one for you, as Sideband does when none is set:
- Which: of the propagation nodes heard announcing in the last day that are serving and ask a stamp cost of 20 or less, the four nearest by hops (and the one picked before) are probed: a Link is set up to each and timed, like a ping. Of those that answer about as fast as the fastest, the nearest is picked. Your own node, if you host one, is left out: it doesn't pass messages on to other nodes.
- Hops are only a hint. They travel outside the announce's signature, so any transport node on the way can make a node look closer than it is. Nothing can make a node answer faster than it really does, so the measured time decides.
- Keeping it: the node picked is checked again every 6 hours, and soon
after syncing with it or sending through it fails. When a check finds no
node that answers, the next comes 10 minutes later, then 20, 40 and so
on, up to every 6 hours; a propagation node newly heard is checked within
a minute. It's replaced only if
it stops answering or another answers in under half its time. The Status
tab shows which node is in use and how it was picked; picking one by hand
(
pin the Network tab, or the propagation node setting in either UI) turns automatic picking off. - Warning: anyone can run a propagation node near you, for instance on the same public entry point. The node picked can't read or change your messages (they're encrypted for their recipients and signed), but it sees who your propagated messages are for and when you collect yours, and it could lose them. Where you can, pick a node you trust instead.
Searching¶
Find messages by what they say: every word typed must be found, in any order, in a message's text, title, attachments' names or what rettui noted of it. It looks through the messages each conversation keeps; older ones moved to the archive open from their conversation (see Data and Storage). Results are newest first (the newest 200 at most), each with who it's with, when, and the part that matched.
- In the TUI:
/in the Messages tab opens the search over all conversations.Tabkeeps it to the open conversation (or goes back to all),↑↓pick a result, andEnteropens its conversation scrolled to the message, picked.Esccloses it; a click on a result opens it. - In the web UI: type in Search messages above the conversations
(or press
/). Inkeeps it to the open conversation, and a click on a result opens it there, loading the older messages first if it's further back. Esc(or emptying the box) shows the conversations again.
Links in messages¶
NomadNet pages and files, LXMF addresses, RRC hubs and web pages written in a message are links, in both UIs and in RRC rooms too:
- Pages and files:
<node>:/page/index.muor<node>:/file/name(also afternomadnetwork://) open in the Browser. - Addresses:
lxmf@<address>orlxmf://<address>open the conversation with them; anlxma://link (an address with its public key, as rettui and Columba share contacts) adds them too, so you can write before they announce. - Hubs:
rrc://<hub>,rrc://<hub>/roomorrrc@<hub>open the hub in Channels (and join the room); a hub you haven't added asks first, as connecting tells it who you are. - Web pages:
https://…andhttp://…open in your browser: from the terminal UI, the computer's default browser; from the web UI, a new tab that isn't told where the link came from (the Android and desktop apps hand it to the system's browser).
A bare hash isn't a link (it could be any destination), and punctuation after a link (a full stop, a closing bracket) isn't part of it.
Copying text: in the terminal UI, drag across a conversation (or a room)
to select text; it's copied when you let go. y on a picked message copies
all of it. In the web UI, select text as on any page.
Message actions¶
- Retry: a message of yours that failed can be sent again, as the same message (the same hash), so a copy that got through anyway isn't shown twice. It goes by the delivery mode chosen now. Its files must still be where they were.
- Sent again when they announce: as in MeshChat, when someone
announces, your messages to them that failed go again on their own (by
how messages to them go), since the announce shows they can be reached.
Text ones only, as a file can be large; not a paper message that
couldn't be written (it would go over the network instead); and a
message isn't sent again so for ten minutes after the last time, however
often they announce. Turn it off with Resend when they announce
(Status,
resend_on_announce). - Forward a message: its text and its files go to another conversation
(or to an address typed in full) as a new message of yours, by how
messages to them go. The files are copied, so deleting either message
leaves the other's. In the TUI, pick it and press
f, then type part of a name or address and pressEnter; in the web UI, it's Forward… in the ⋯ beside it. - Export a conversation: all of it, archived messages too, as a text
file: who wrote what and when, with the names of files, locations and
reactions.
Ein the TUI's Messages tab writes it toexports/in the downloads folder (and says where); Export as text in the web UI's Contact dialog downloads it. - Delete a message: it goes from rettui, with any files rettui saved for it (received files, and ones uploaded in the web UI). A file you sent from elsewhere on your computer stays where it is. It isn't deleted from the other side.
- Delete a conversation: all its messages go, including those moved to the archive, and the files rettui saved for them. Your name for the contact and your notes stay (they're about the person, not the conversation).
In the TUI, pick a message (m, or click its name line) and press t to
retry, c to cancel sending it, or x to delete; X deletes the open
conversation. In the web UI, ↻ Retry shows on a message that failed or
was cancelled, ■ Cancel on one being sent, and the ⋯ beside a message's
buttons has Delete. Delete conversation is in the Contact dialog.
Both UIs ask before deleting.
Contacts¶
Each person you message can have a name of your own for them, shown instead of the one they announce (in the conversation list, notifications and everywhere else), and notes for you alone.
- In the TUI:
copens the open conversation's contact card: who they are, the name they announce, their address, when they were last heard and how far away, and your notes.rrenames them (empty goes back to their own name),eedits the notes (line breaks show as ↵ while editing),ycopies their address,ppings them,P,T,DandIfind, probe and forget their path and look up whose address it is,Xdeletes the conversation, andEsccloses the card. Its buttons can be clicked too. - In the web UI: the Contact button above the conversation. On a touch screen (the Android app, say), holding a conversation in the list opens it too, so the actions are a press away without opening the chat.
- Network tools: the card has Path (
P), Probe (T), Forget path (D) and Identity (I), as in the Network tab: they find the path to them, time an answer asrnprobedoes, drop a path that has gone stale, and show whose address it is. The card shows the last path and probe results. In the web UI the Contact dialog has Path… (with Find path, Probe and Forget path) and Identity…. The Tools tab has the same tests for any address. - Ping: rettui finds a path to them and times setting up a Link to
their LXMF address (closed straight away; nothing is sent over it), then
shows how long it took and how many hops away they are, and how well
their answer was heard (RSSI, SNR, link quality) when it came in over a
radio that reports it, such as an RNode. Any LXMF client
answers, while it's running. The card keeps the last answer;
rettui ping <address>does it from the command line. - Sharing your address:
cin the Status tab (TUI), or QR code next to your address (web UI), shows it as a QR code: anlxma://link with your address and public key, the way Columba shares contacts. Someone who scans it can write to you before hearing your announce. Copy next to your address in the web UI's Status, oryin the TUI's, copies the same link;rettui address --linkprints it. - Icons: Sideband, Columba and MeshChat let people pick an icon (a Material Design Icon in a colour on a colour), which comes with their messages. rettui keeps the newest one each person sent. The web UI shows it beside their name in the conversation list, above the conversation and on the map. The TUI shows its colours beside their name in the conversation list (with their name's first letter, as a terminal may not have the icon itself), and its contact card names it, in its colours.
- Your own: Icon in the settings (Status), with Icon colour and Icon background. Type part of a name in the web UI and pick from the icons that match; in the TUI, type the name. Once set, it goes with every message you send (not paper ones), as Sideband sends its own, and shows beside your name in the web UI. Empty, the default, sends none.
- Faces: everyone without an icon of their own gets a face instead: LXMFace's picture of their LXMF address, an 8×8 pattern in three colours, as Ratspeak shows them. An address always gives the same face, in every app that draws LXMFace, so you can tell people apart at a glance even before they've named themselves. An icon someone set in Sideband, Columba or MeshChat always comes first. The web UI shows faces where icons go (and your own beside your name, unless you've set an icon); the TUI draws them in half blocks: small beside each conversation, full size on the contact card.
- Adding someone from theirs: paste their
lxma://link where you'd type an address (nin the TUI, + New in the web UI), or read its QR code like a paper message (a picture of it, or the camera in the web UI). rettui checks the key belongs to the address, keeps it, and opens the conversation. - Passing someone's address on: Copy address (
yon the contact card or in the conversation, the button above it in the web UI, and Copy LXMF address on an RRC user) copies anlxma://link with their public key once rettui has heard their announce, so whoever you give it to can write to them straight away. Before that it copies the address alone, and says so.
Blocking and spam¶
- Unknown senders: someone who isn't a contact (you haven't trusted them, and you've never written to them) is marked with a ? in the conversation list, and their conversation asks what to do with them, as NomadNet's Untrusted list does:
- Trust them: they're spared the stamp cost (below), and given tickets.
- Leave as is: their messages are taken, but they aren't trusted. The question goes away.
- Block them (below).
Unknown senders (Status, unknown_senders) decides what becomes of
their messages:
- show (the default): as above, like anyone's, marked ?.
- requests: kept aside as message requests, as Signal does: listed
last, under Message requests in the web UI and marked request in
the TUI, with no notifications and not counted as unread. Trusting
them, leaving them as they are, or replying makes it a conversation
like any other; blocking them, or deleting it (the web UI's request
has Delete beside Block), gets rid of it.
- ignore: dropped altogether, as Sideband can. A settings file that
had Ignore unknown senders on reads as this.
Anyone you've written to, trusted, or left as is always gets through.
- Blocking someone drops their messages, deletes the conversation with
them, and blocks their identity in Reticulum (its blackhole list), so
their announces and traffic are dropped too, as NomadNet does. If rettui
uses a shared instance (rnsd, NomadNet), that instance blocks them, for
every program using it. Blocked contacts are listed under the Network
tab's Blocked filter, where they can be unblocked; an unblocked contact
is an unknown sender again. Blocking needs their identity: if it isn't
known (no announce heard), rettui still drops their messages and says
so in the log, and blocks them in Reticulum the next time it starts and
knows it.
- Stamp cost (stamp_cost, 0 by default): proof of work asked of
anyone who isn't a contact, announced with your address as Python LXMF
does. Their client works out the stamp before sending (a cost of 8 takes
a moment, 16 a lot longer); messages without a valid one are dropped and
the log says so. Contacts (trusted, or written to) are spared it.
Trusted contacts are also given a ticket with your messages (LXMF's
ticket field, at most once a day): their client stamps later messages
with it instead of doing the work, which matters to those who aren't in
your contacts on their own side. Tickets they give you are used for your
messages to them in the same way. rettui keeps tickets in
tickets.json, using rsLXMF's ticket store.
- Largest message (max_message_kb, 1000 by default, as LXMF's own
default; NomadNet uses 500): bigger direct transfers are refused before
they're downloaded, and bigger messages from a propagation node are
dropped. 0 takes any size.
In the TUI, the contact card (c) has Trust, Leave as is and Block
(t, l, b), and b on an LXMF peer in the Network tab blocks or
unblocks them. In the web UI, the question shows above an unknown sender's
messages, the Contact dialog has Trust and Block, and the Network
tab has Block and Unblock on LXMF peers.
Reactions, locations, commands and voice messages¶
Other LXMF clients send some messages with no text, only an LXMF field. rettui shows what each one is, rather than an empty message:
- Reactions (LXMF field
0x40, as Columba and MeshChatX send them) show under the message they react to, with who reacted. A reaction that arrives before its message waits for it. A reaction to one of your messages gets a notification; it isn't counted as unread. - Sensor readings (Sideband's telemetry, field
0x02, beside or without a location) show under the message, one a line, as Sideband's own list says them: battery (charge, charging, temperature), pressure, temperature, humidity, light, acceleration, gravity, rotation, the magnetic field, proximity, the radio link (quality, RSSI, SNR), where it was received and how far, the processor (how busy, its load averages), memory, storage, tanks and fuel, power used and made, information text and readings of the sender's own, and the interfaces it makes known (Sideband 2.x's Interfaces sensor, listed under Interfaces found). Reticulum transport and propagation node statistics, and connection maps, are only named. Like location updates, readings don't notify you or count as unread, and newer ones replace the ones before. - Locations (Sideband and Columba telemetry, field
0x02) show as a line with the coordinates. Click it (or open it, below) to see it on OpenStreetMap, or on the map. Location updates don't notify you or count as unread, and a newer one replaces the one before it while nothing else was said in between, so a shared location doesn't fill the conversation. - Commands (Sideband's, field
0x09), such as asking for your location or a ping, are shown in words, and don't notify you. - Answer commands (Status,
answer_commands) answers pings, echoes and signal report requests as Sideband does: "Ping reply", "Echo reply:" and the text, and, for a signal report, how the message asking was heard ("Link Quality", "RSSI" and "SNR", as many as the radio said), or "No reception info available" when it came another way. It's off by default; trusted answers only contacts you trust, contacts any contact. The answers go as messages, shown in the conversation, at most once a minute to each sender; the command's line says whether, or why not. Only a message's first 8 commands are read, and only an echo's first 500 characters are sent back. - Requests for your location are answered only if Location requests says so (see below). Plugin commands aren't run.
- Sending them:
Kin a conversation (or Command on the contact card,kthere) sends one, typed as in Sideband's command box:ping,echoand some text,signalfor a signal report, orlocationto ask where they are. The contact card's Ask where they are (w) sends that last one. In the web UI they're on the contact dialog: 📍 Ask where they are and Command… (orK). A command goes as a message with no text, the way that conversation's messages go (by paper, it goes the usual way), and its line says what was asked; one that failed can be sent again. Sideband answers a ping, an echo or a signal report with a message, and a location request with its location, which goes on the map, if it's set to answer you (for most, only contacts it trusts). - Voice messages (field
0x07) are saved with the attachments, and play in the web UI and in most players (oin the TUI opens them): - Opus recordings are saved as
.oggfiles, as they came. - Codec2 recordings (the low-bandwidth modes MeshChat, Columba and
Sideband can send) are decoded when they arrive and saved as
.wavfiles, up to ten minutes. Every mode is decoded: 3200, 2400, 1600, 1400, 1300, 1200, 700C and 450 to 8 kHz mono, and 450PWB (450's bits decoded "pseudo wideband") to 16 kHz. A recording without a whole frame is saved as it came (.codec2) and marked as not playable. - Not from strangers: a Codec2 recording from someone who isn't a
contact is saved as it came (
.codec2) and marked as not playable, and stays so if you add them later. Decoding costs time and memory, so only contacts' recordings are decoded. - Recording one in the web UI: the 🎤 button beside Attach
records from the microphone; press it again (⏹ shows how long so far)
to stop, listen to it, then Send it, with text if you like.
Browsers only let a secure page use the microphone: open the web UI at
localhost, or over HTTPS. - Recording one in the TUI:
vin a conversation starts recording (the box you write in says 🔴 and how long so far),vagain stops, then write anything to go with it andEntersends it (Ctrl-Xthrows it away). While writing,Alt-Rstarts and stops one;Escthrows a recording away while it records. The TUI records with a program that's installed rather than a sound library (which servers and Docker images don't have): the first ofparecord(PulseAudio and PipeWire),arecord(ALSA),rec(SoX) andffmpegit finds (on macOSrecorffmpeg, on Windows SoX'ssox). Voice recorder (Status, Messages,voice_recorder) runs another instead: it must write raw 16-bit little-endian mono 8 kHz sound to its output until it's stopped, likearecord -q -t raw -f S16_LE -c 1 -r 8000. It's changed only in the terminal, as it's a program run. - Either way it goes as Codec2 in the mode Send voice at (Status,
Messages,
voice_mode) has: 3200 bit/s by default, the clearest (about 400 bytes a second, so a minute is 24 KB), down to 1200 (a minute in 9 KB) and 700C (a minute in 5 KB, for LoRa, though harder to make out). Sideband, MeshChat and Columba play them all, and you hear what they will. Up to five minutes. A message that failed goes again in the mode it was recorded in. rettui doesn't send 450: Codec2 only decodes that one well. - Played as they come:
Vin a conversation, or ▶ Voice in its ⋯ menu in the web UI, plays their voice messages as soon as they arrive, like push-to-talk in Sideband (the list marks it ▶ voice). In the terminal, rettui opens each with the program your desktop plays sound with, asodoes. In the web UI, every browser showing rettui plays it, one after another; a browser that won't play sound before the page has been touched says so, and the message waits to be played as usual. Text messages, and voice messages from anyone else, don't play. - Voice calls (Sideband's, over LXST) aren't something rettui can make or answer. LXST, the library they use, is published under CC BY-NC-ND 4.0, which doesn't allow adaptations of it to be shared, and there's no separate description of its protocol to build one from. Voice messages work with the same clients.
- A message with nothing rettui can show says so, naming the fields it carried, without a notification.
Locations and the map¶
You can share a location as Sideband does (LXMF's telemetry field, with the time, latitude, longitude and, if known, height and accuracy), so Sideband and Columba show it on their maps:
- In the TUI:
Lin a conversation asks for a location (latitude, longitude, such as51.5074, -0.1278, or ageo:link), filled in with this station's Location (Status,location) if it's set;Entershares it. - In the web UI: the 📍 button beside the microphone (or
L) offers where the device is (the browser asks you first; browsers only say on a secure page, so open the web UI atlocalhostor over HTTPS), this station's Location, or one typed.
A location goes as its own message, the way the conversation's messages go (not on paper: a paper message carries text only), and shows in the conversation like anyone's. It's sent once, unless you share it live:
- Sharing live (as Columba does): updates for 15 minutes, an hour, eight hours or until you stop, then a message saying you've stopped, which Columba shows (and rettui does too). Each update replaces the one before it in the conversation, so a live share is one message there, and its header says 📍 live until … with Stop (web UI).
- In the web UI: 📍 Share live in the share dialog shares where the device is, as it moves: rettui sends it at most once a minute, and only while a page of rettui is open on that device (with no page open for five minutes, updates stop until one is). On a page that can't say where the device is (not HTTPS or localhost), it shares this station's Location instead.
- In the TUI:
L, thenlive 15m,live 1h,live 8horlive on(until stopped), shares this station's Location every few minutes.Lagain stops it. - Live shares last while rettui runs: stopping rettui stops them (without the message saying so).
Location requests (Status, location_requests) answers Sideband's
requests for your location with this station's Location: off (the
default), trusted (only contacts you trust) or contacts (any contact).
As with Answer commands, the answer is a message in the conversation, at
most one a minute to each sender, and the request's line says whether it
was answered, or why not. With no Location set, nothing is sent.
Send sensor readings (Status, Location, telemetry_sensors; off unless
turned on) sends this computer's readings with its location (an answer to
a location request, a location shared, live updates), as Sideband sends
its own, so Sideband shows them on your entry: the battery's charge and
whether it's charging (Linux), how busy the processor is with its load
averages (Linux and macOS), memory used (Linux), and the storage rettui
keeps its data on (Linux and macOS). Your message shows what was sent.
Windows sends none of them.
Send to trusted every (Status, Location, telemetry_every_mins; 0, off,
to start with) sends this station's Location to every contact you trust
every so many minutes, with sensor readings if Send sensor readings is on,
so they can follow it on their map, as Sideband sends its telemetry on a
timer. It goes as a live update does: each one replaces the one before it
in the conversation. Someone you're already sharing it with live gets the
live updates instead. With no Location set, nothing is sent.
Tracking someone asks where they are every so many minutes, while
rettui runs, as Sideband's location requests do, so the map follows them.
Track on the contact card (f, then the minutes: 1 to 1440) starts it,
and f again stops it; in the web UI it's 📡 Track… on the contact
dialog. The conversation's header says 📡 asking every 10 min (with
Stop in the web UI). The requests aren't shown in the conversation, and
the next isn't sent until the one before has gone; each answer replaces the
one before it. They answer only if they're set to answer you (in Sideband,
most answer only contacts they trust). One that couldn't be sent is said in
the log.
A telemetry collector is a station (a Sideband with its collector on, or a rettui with Be a collector) that keeps everyone's newest locations and passes them on when asked, so a group sees each other on the map without each asking each. The settings are in Status, Location:
- Telemetry collector (
telemetry_collector) is the collector's LXMF address. - Send to collector every (
collector_send_mins; 0, off, to start with) sends this station's Location to it every so many minutes, with sensor readings if they're sent. It goes as a live update does. - Ask collector every (
collector_ask_mins; 0, off) asks it every so many minutes for the locations it has that are newer than the last it passed on (a week's, the first time). The requests aren't shown in the conversation. - What a collector passes on is used only when it comes from your collector or a contact you trust. Each place goes on the map, marked via the collector, unless that person has since sent their own. The message it came in says how many there were and how many were new. The newest 1,000 places are kept.
- Be a collector (
collector_serve): off (the default), trusted (only contacts you trust) or contacts (any contact). It answers collector requests with the newest location of everyone who sent you one, and this station's, at most once a minute to each. Places that came through another collector aren't passed on, nor anyone's who is blocked. While it's off, a collector request is answered as a location request (as Sideband does), if Location requests says so.
Telemetry to MQTT (telemetry_mqtt, in Status, Location) passes places
on to an MQTT server, as Sideband's setting of the same name does, for home
automation or a dashboard. Give the server as mqtt://host,
mqtt://host:1883 or mqtt://user:password@host (the password is kept in
the settings file as written); empty, to start with, sends nothing. Every
place rettui hears (in a message, a live update or from a collector), and
this station's when Send to trusted every sends it, is published under
the sender's LXMF address, as Sideband lays it out:
lxmf/telemetry/<address>/location/latitude, …/longitude, …/altitude,
…/speed, …/heading, …/accuracy and …/updated, and
lxmf/telemetry/<address>/time/utc, each value as text (empty when it
isn't known). rettui connects for each place and leaves once the server has
taken it (MQTT 3.1.1, QoS 1, without TLS); the log says when it can't.
Places from anyone blocked aren't passed on. Other sensors aren't sent.
The map shows everyone's newest location, the newest first, and this station's if it's set. Someone who said they'd stopped sharing (as Columba does) isn't on it, nor is anyone blocked. Interfaces others make known that say where they are go on it too, marked ▲, as Sideband 2.x shows them.
- In the TUI:
Min Messages opens it, on the open conversation's place if they shared one. It draws the coastlines when it's zoomed out far enough to show them, with each place on it, and lists them with how long ago and how far from this station.↑↓pick a place,+/-(or the mouse wheel) zoom in on it and out,0shows them all again,Enteropens the conversation (or, for an interface, shows it in the list of interfaces found),oopens the place on OpenStreetMap,wasks the one picked where they are now (as Ask where they are on the contact card does),xdeletes their locations,ileaves interfaces off the map (or puts them back),Esccloses it. - In the web UI: 🗺 beside + New (or
M), or Map beside a location in a conversation. Drag it, zoom with the wheel, a double click, two fingers or+/−, and⤢shows them all. A click on a place or in the list shows it; the list also opens the conversation, or the place on OpenStreetMap. How far each may be off shows as a circle around it. 📍 Ask where in the list asks someone where they are now.▲hides interfaces or shows them again, and Details beside one shows what's known of it. - Trails: each place someone sends (a location, a live update, an answer when tracked) and each a collector passes on is kept on their trail, even though each update replaces the one before in the conversation. The map draws it as a line to where they are now, the place picked brighter, and the list says trail of 12. Each trail keeps the newest 100 places from the last 30 days, a place they stay at once, for up to 200 people.
- Deleting someone's locations:
xon the map (Delete locations in the web UI's list), after asking, takes their place and trail off the map, and what collectors passed on about them. Their messages stay in the conversation. Locations they send after that show again.
The web map's pictures (tiles) come from Map tiles (Status, map_tiles):
OpenStreetMap's by default, or any other address with {z}, {x} and
{y} in it. From the web UI a new source must be an https:// address on
the public internet; one on a local network is set in the terminal UI. rettui fetches them itself, so a phone with no internet of its
own still gets them as long as the computer running rettui has it, and the
page loads nothing from elsewhere. They're kept a month in map-tiles/
(up to 200 MB, the oldest going first), so places looked at before still
show without the internet. The tile server learns which parts of the map
are looked at, as with any online map; with Map tiles empty, nothing is
fetched, and the places are drawn on a plain grid.
For a map with no internet at all, Offline map (Status,
map_tiles_file) names an MBTiles file: tiles in one SQLite file, as
MOBAC, QGIS, TileMill and others make them (raster tiles: PNG, JPEG or
WebP pictures; vector tiles aren't drawn). Its tiles come first; any it
hasn't come from Map tiles, if that's set. Zoomed in closer than the
file goes, its closest tiles are shown enlarged (up to six levels), rather
than nothing. The file's credit (its attribution) shows in the corner.
It names a file on the computer running rettui, so it's set in the
terminal UI or settings.json; the web UI shows it, but can't change it.
The file is only read.
To react, pick a message and choose an emoji:
- In the TUI:
mpicks the newest message, and↑↓pick another (or click a message's name line). The picked message shows its buttons:rreply,ereact,ycopy its text,oopen its file or location.eopens the emoji picker;Entersends the reaction.Escputs the message down. - In the web UI: hover over a message and click 🙂 React. The button stays on a touch screen too; holding a message opens a menu with React… as well.
A reaction is sent as an LXMF message with no text and the reaction field, the way Columba does, so clients that don't know reactions (Sideband, NomadNet) may show it as an empty message. A reaction that failed to send shows as failed: react with the same emoji again (or click it, in the web UI) to send it again.
Paper messages¶
A paper message is an LXMF message that travels outside Reticulum: as an
lxm:// link or its QR code. You can print it, show it on a screen, or send
the link any way you like. It's signed and encrypted for the recipient like
any other message, so only they can read it. The format is Python LXMF's, so
Sideband and NomadNet can read what rettui writes, and rettui can read theirs.
- Writing one: pick the paper delivery mode (
dorCtrl-Pin the TUI, Paper (QR code) in the web UI), then write the message. - rettui only needs the recipient's key, from an announce heard at some point. They don't have to be online.
- Paper messages carry text only, up to about 1,800 characters.
- When the message is ready, its QR code opens:
- TUI:
ycopies the link, andssaves the QR code as an SVG image in the downloads folder, ready to print.pprints it: rettui hands a PNG of the code to Print command (Settings, Messages,print_command, with{}where the file goes), or else tolporlpr. On Windows, set the command first. If the window is too small for the code, rettui says so, and you can still copy, save or print it. - Web UI: Copy link, Share (on phones), and Print, which prints the code alone.
- TUI:
- The message then shows ✓ paper message.
Pin the TUI, or its QR code button in the web UI, opens the code again. - Reading one: rettui checks the message is for you, decrypts it, and checks the signature like any other message. It then goes into the sender's conversation, which opens.
- TUI: press
p, then paste the link or give the path to a picture of the QR code. You can also paste anlxm://link straight into the Messages tab. - Web UI: Read paper, beside + New. Paste the link, or scan the
code:
- Scan uses the camera, in browsers that can read QR codes themselves (Chrome on Android and macOS). The page has to be secure (https or localhost).
- Scan (take a picture), or From a picture, works in every browser: take a photo or pick a picture, and rettui finds the code in it.
- A message you've already read in is only reported, not added twice.
Formatting (Markdown)¶
LXMF's renderer field says how a message's text is written. Sideband and NomadNet compose in Markdown; rettui does too.
- What you write is marked as Markdown, so clients that format it show
**bold**,*italic*,~~struck~~,`code`, lists, quotes (>), headings (#), code blocks and links formatted. Turn Write in Markdown off in the settings to send plain text.rettui sendsends plain text. - What you get marked as Markdown shows formatted in both UIs, and so does a message marked as Micron (NomadNet's page markup). Line breaks are kept, as in a chat. Previews in the conversation list and notifications leave the markup out.
- Safety: HTML in a message is shown as text, never run, and in the web UI only web and mail links can be clicked (others show their address).
Replies¶
A reply names the message it answers, and the start of that message's text goes with it, so the other side sees what it answers even without that message. It's LXMF's own reply format, as Columba and MeshChatX send it: replies between them and rettui show as replies both ways. Clients that don't support replies yet (Sideband, NomadNet, MeshChat) show an ordinary message.
- In the TUI:
rreplies to the newest message they sent, and so doesCtrl-Rwhile writing.↑↓then pick another (the one chosen is marked in the history), andEscstops replying. To reply to a message further back, pick it (m, or click its name line) and pressror click ↩ Reply. - In the web UI: hover over a message and click ↩ Reply. On a touch
screen, hold the message and choose Reply. The box shows what you're replying to;
Escor × stops replying. - Showing them: a reply shows the first line of what it answers, under who wrote it. That's taken from the message itself when it's here, and from what the reply quoted when it isn't (it's older than the messages kept, or was never received). Click the quote to scroll to the message.
A message you send can be replied to once it's sent: replies name it by its hash, which it has from then on. What you're replying to stays with the conversation's draft.
Comments and continuations (LXMF 1.2's fields 0x41 and 0x42) are
shown for what they are, in both UIs, when another client sends them:
- A comment on a message shows 💬 comment on and the first line of that message, which a click scrolls to.
- A continuation carries on from an earlier message. Straight after it, from the same side, it's shown as part of it, with no name or time of its own; anywhere else it shows … carrying on from and the start of that message.
Their text is the message's own, so clients that don't know them (and rettui before this) show an ordinary message. rettui doesn't send them.
Emoji¶
Both UIs have the same two ways to add an emoji to a message, and to what you write in a channel:
- The picker:
Ctrl-E(or the 🙂 button in the web UI) opens it, at the emoji you used lately (both UIs share the list). Type to search by name or shortcode, or go through the groups (Tabin the TUI, the tabs in the web UI).Enteror a click puts the chosen one in, and in the web UI Shift-click keeps the picker open for another. - By name: type
:and the start of a name, such as:dra, and a list of the emoji it could be opens above the box.↑↓choose,TaborEnterputs one in, andEsccloses the list. Typing the whole name, such as:dragon:, turns it into 🐉 right away. Names are GitHub's shortcodes (:+1:,:tada:); words of an emoji's Unicode name find it too.
The emoji are Unicode's, up to Unicode 15.0 (2022): many systems still draw
newer ones as boxes. In the web UI, Ctrl-E isn't used on a Mac or an
iPhone, where it moves to the end of the line and Ctrl-Cmd-Space opens the
system's own picker.