Skip to content

Network

The Network tab lists what rettui hears on the network; the Status tab shows your identity, your interfaces and the log.

  • Heard announces: the Network tab lists the LXMF peers, NomadNet nodes and propagation nodes you've heard, with their names, addresses, hops and when they were last heard.
  • Names are cleaned: a name someone announces could otherwise pass for another, or spill over the screen. As NomadNet does, rettui drops characters that hide or turn text around (direction overrides, zero-width and private-use ones), reads compatibility forms as the letters they look like (ADMIN as ADMIN), keeps at most four accents on a letter, makes blank-looking characters and line breaks one space, and keeps 128 characters. Unlike NomadNet, emoji stay. Names heard before this are cleaned as rettui starts. Your own name, and your propagation node's, go out the same way, emoji included, as Sideband and NomadNet send them (the LXMF library rettui uses would drop the emoji, so rettui builds its announces itself).
  • Hearing others takes time: there's no list to download; each peer and node announces on its own schedule, many only every few hours, so a new install's list fills over its first hours. Announcing yourself (A, or Announce in the web UI) lets others find you. While nothing is connected, the empty list says so and points to the getting-started guide.
  • Finding: filter by kind (f), or search by name or address (/), with the matches highlighted. Addresses can be pasted in any common form (<hash>, lxmf@hash, hash:/page/index.mu).
  • Sorting and interfaces: the list is last heard first; s in the TUI (or the order menu in the web UI) sorts it by name or nearest first instead. Each row says which interface its path goes through, when one's known (from the path table, read every half minute), and i (or the interface menu) keeps the list to those through one interface: what's heard over the LoRa radio, say, rather than the internet.
  • Acting on a row: message a peer, browse a node, or use a propagation node for sync, and copy any address.
  • Announces as they're heard: a (or Announces in the web UI) shows every announce in place of the list, as it arrives, of every kind: LXMF peers, NomadNet and propagation nodes, RRC hubs, LXST calls, and whatever else announces on the network (tagged OTHER, with a name when its announce carries one as text). A propagation node's says what runs it, as LXMF 1.2 announces it and Sideband shows it (lxmd 1.2.1, rettui 1.2.0). The list keeps one row per peer or node; this shows each announce, with when it was heard, so it's where to see who's announcing how often, or what's on a new interface. It follows the newest; moving up holds it where you are (End, or scrolling to the bottom in the web UI, follows again). Filter by kind (f), search (/) and keep to an interface (i) as in the list; Enter opens what rettui can, and P, T and y find a path, probe and copy. rettui keeps the newest 1000 heard since it started. A burst of announces on an interface that just came up is held back by Reticulum (as it is for every program on it), so some may show up later, or not at all.
  • Reticulum's tables: t (or Tables in the web UI) shows, in place of the list, what Reticulum knows, as rnpath -t and rnpath -r list it. The path table has every path known, nearest first: where each goes, its hops, the transport node it goes through, the interface, and how long it's kept ("3 hops via <09090909…> on RMAP World, kept for 3 days"). Announce rates (f switches) has how often each destination announces, those held back first: a destination that announces faster than its interface allows has its announces dropped for a while ("held back for 12 min · 2 times too often · 4.2 an hour · announced 3 min ago"). Reticulum keeps rates when it passes announces on (transport). Names come from contacts, the list and the announces heard. Search (/) finds rows by name, address, the transport node or the interface; P, T, D and y act on the row picked as in the list (in the web UI, a row opens its path). The tables are read again every 5 seconds while shown (R reads them now), the shared instance's when rettui is a client of one. The web UI shows the first 500 rows found.
  • Paths: to reach a destination, rettui needs a path to it: which interface it goes out on, and through which transport node. Announces bring paths; for one not heard yet, rettui asks for a path, up to three times over a minute (at once, then after 15 and 52 seconds). One request often goes unanswered: it's lost on the way, or reaches a node that hasn't heard of the destination yet. For 45 seconds, Reticulum nodes take further requests for a destination as part of the one they're still working on, so the third request waits until then. Loading a page, connecting to a hub, and sending a message, syncing or pinging all do this; while it goes on, a hub connecting, and a page loading in the TUI, say which request they're on.
  • Stale paths: a path can go stale: the destination moved, or a node on the way went down. When a Link over a known path gets no answer, rettui forgets the path, asks for a fresh one, and tries once more (except for a ping, which times one try).
  • Finding or forgetting a path: in the TUI, P finds the path to the selected row (or to any address typed), and D forgets the selected row's path. In the web UI, Path on each row opens a dialog with the path and Find path, Probe and Forget path buttons, and Find a path… above the list opens it for any address. A path shows as its hops, the transport node it goes through, the interface, and how long it's kept unless heard again ("2 hops via <0a1b2c3d…> on RMAP World, kept for 6 days"). Forget a path that has gone stale, and the next use asks for a fresh one.
  • Probing: T (or Probe) times an answer from the selected destination, as rnprobe does, finding a path first. LXMF addresses prove the packets they get, so they're sent a probe packet ("answered in 182 ms, 2 hops away"). NomadNet nodes, propagation nodes and RRC hubs don't, so rnprobe to one always times out; rettui times setting up a Link to them instead, closed straight away, and says so ("a Link opened in 240 ms").
  • From the command line: rettui path <address> finds and prints a path, -d forgets it, and -t lists every path known; rettui probe <address> probes (see Running). While rettui is the shared instance (the first Reticulum program started with share_instance on; a config rettui makes for you has it off, so other programs on the machine can't use rettui until you turn it on), these use its paths, and Reticulum's own rnpath and rnprobe work against it too.
  • Sending a file with rncp: F in the Network tab (in the list, the announces or the tables), or Send a file… in the web UI, sends a file to someone running Reticulum's rncp -l, as rncp FILE ADDRESS does: it lands in their folder. Give the address their rncp -l prints (the selected one is filled in). Their listener lets in only the identities it allows, so give them yours (rettui shows it there): they add it with rncp -a, or start the listener with -n to let anyone send. A file is up to 32 MB. In the terminal you type its path; the web UI sends one your browser picks, never a file from the computer rettui runs on. How it's going shows as it goes, and the log says when it arrived or why it didn't.
  • Receiving files with rncp: Receive files with rncp (Settings, Hosting; turned on in the terminal) makes rettui listen at your rncp address, as rncp -l does, and save what is sent to Received files folder (received/ in the data directory unless you set one). Nobody may send until you list them in Who may send files: identity hashes, as rncp -a takes, separated by commas (a sender sees theirs in the send dialog; I in the Network tab shows yours and anyone's). Someone not on the list is turned away and counted. A file is saved under its own name, without any folders, and never written over one that's there: a second notes.txt becomes notes.txt.1. Status shows your rncp address and how many files came; the log names each one with who sent it, and the web UI's Send a file… dialog lists the latest. rettui doesn't limit how big a file may be, so list only people you trust to send sensibly; the web UI can turn this off, not on, and can't change who may send or the folder.
  • Getting a file from an rncp listener: O in the Network tab (in the list, the announces or the tables), or Get a file in the web UI's Send a file… dialog, asks a listener run with rncp -l -F for a file, as rncp --fetch does. Give its address, then the file's path on that computer (relative to its jail folder if it runs with -j). The listener must allow your identity, shown in the dialog (rncp -a), unless it lets anyone (-n). The file is saved in Received files folder, under its own name and never over one that's there. A listener that isn't run with -F, or doesn't allow you, closes the link, and rettui says so. The web UI can ask for a file but only saves it on the computer rettui runs on.
  • Speed test: v in the Network tab, or Speed test in the web UI, measures how fast data goes between you and someone else, as NomadNet 1.4's speed test does, so the other can use rettui or NomadNet (Utilities, Speed Test). Each has a speed test address, shown there: give them yours and enter theirs. Either of you can then send a test of random bytes, from 2 KB to 16 MB (← → pick the size, Enter sends), and both see how long it took, as a rate (Upload: 1.2 Mbps, Download: 1.1 Mbps). While it's open, rettui takes tests from the address you entered and turns away anyone else's; closed, it takes none.
  • Interfaces found: e in the Network tab, or Interfaces found in the web UI, lists the interfaces others make known, as Sideband 2.x does: the entry points, RNodes and I2P addresses interface discovery finds (Discover interfaces in the Reticulum config), and those contacts send in their telemetry (Sideband's Interfaces sensor). Each says how to reach it (host and port, or the radio's frequency, bandwidth, spreading factor and coding rate), whether its node passes traffic on, its network name if it has one, and, for one discovery found, how many hops away it is and when it was heard. ● marks one rettui is connected to (see Discovered entry points). Enter (Add to Reticulum) adds the one picked to the Reticulum config, kept in its history: an entry point as a TCP client, which connects when Reticulum restarts, an I2P address as an I2P interface, and an RNode's radio settings as an RNode interface that's off until you set its port and TX power. One that points at this device isn't added. m (On the map) shows it on the map, if it says where it is, and y (Copy) copies where to reach it. Blocked contacts' aren't listed.
  • Identities: I in the Network tab (in the list, the announces or the tables), or Identities… in the web UI, shows your addresses (your identity, LXMF address, node, propagation node, RRC hub and speed test address), and whose another address is, as NomadNet 1.4's Identity utility does: the identity behind it, what it is (an LXMF address, a node, a propagation node and so on), and the other addresses that identity has. An address that hasn't been heard is asked of the network, which can take a while. The selected address is looked up; type any other. y (or Copy) copies a row's address.
  • Status: the Status tab shows your identity and LXMF address, your first steps until they're taken (see Running), the network state, each interface with its traffic, the last sync, the propagation node you host (if any), and a log.
  • Interface trouble: the log shows why an interface won't connect or dropped, as the Reticulum libraries report it (for example Interface Dead Link: TCP connect failed: Connection refused). It also shows when an interface goes offline or comes back online. The same trouble again within five minutes (a connection retrying) is counted rather than logged again, and a Reticulum restart starts the count afresh. rettui.log keeps everything.
  • What to do about it: common trouble gets a plain-words hint after the error: a host name that can't be looked up (check the internet connection and the host name), a connection refused (the entry point may be down or the port wrong), no answer (down, or a firewall), no route (no internet), a port already in use (another Reticulum, such as rnsd, or a second rettui), a radio that isn't plugged in, a serial port you may not open (on Linux, the dialout group), a device another program has open, no I2P router running, no IPv6 for the Auto interface (common in Docker containers), and an interface that has stopped retrying. The command-line commands print the same lines.
  • Interfaces: the Status tab lists each one, online (●) or not (○), with what it has received (↓) and sent (↑), and what rnstatus shows of it: its rate (for a radio, the air rate), MTU, mode if not full, clients (for a server), and announces queued or held back and packets dropped, when there are any.
  • Signal: a ping says how well the answer was heard (RSSI, SNR and link quality, as rnprobe does) when it came in over a radio that reports it, such as an RNode. So does a message that came in one packet straight from the sender (sent opportunistically, as Sideband and others send short messages to someone they have no Link to): 📶 beside it says how it was heard, as Sideband shows it, and it's kept with the message. A message sent over a Link (most direct messages, and any too big for one packet) doesn't show it: the Reticulum library rettui uses doesn't say how a Link's packets were heard. Nor does one from a propagation node, which wasn't heard from the sender.
  • Traffic: the corner of the sidebar, under the interface count, shows how fast data is coming in (↓) and going out (↑) over all interfaces, updated every few seconds. In the web UI, hovering over it shows the totals. Under each interface in the Status tab, a graph shows its own traffic over the last ten minutes (a reading every five seconds), in (↓) and out (↑) against its busiest moment, with how fast it's moving now: bars in the terminal UI, lines in the web UI (in cyan, out magenta). An interface that's been quiet throughout has none. The graphs start when rettui does.

The Tools tab

The Tools tab (- in the TUI, Tools in the web UI) has the tests of the network in one place, for trying an address or your own settings without picking a row first. What Network and the contact card have (paths, probes, whose an address is, the speed test and rncp files) is here too, and each keeps working where it was.

  • Find a path, Probe, Forget a path (P, T, D): for any address typed (the one last tried is filled in). The addresses tried lately are listed with how the path and the probe went, whichever tab or contact they were tried from. In the web UI, Path & probe… opens the path dialog (Find path, Probe, Forget path) for an address.
  • Identities, Speed test, Send a file, Fetch a file (I, v, F, O): as in the Network tab. The web UI has the first three as buttons, and Path table for Reticulum's tables.
  • Check interfaces (c): the Interfaces list shows each one, up or down, with its traffic, rate and settings, as the Status tab does, and for those that connect to a host (the entry points of the Reticulum config) the host and port, and whether it has an IFAC network name or passphrase (the other end needs the same; the passphrase is never shown). The check tries a TCP connection to each entry point that's switched on, from this computer, and closes it at once. A server interface (one that listens, such as a TCPServerInterface) is tried on this computer's own address and its port: that shows rettui is listening, not whether your router, firewall or Docker port mapping lets others in. It says how long the connection took ("up · 120 ms"), or why not ("down · refused": the host is down or the port is wrong; "no answer": down, or a firewall; "unreachable": no route; "name not found"), with what to do about it. A host that answers here may still not take Reticulum's traffic (an IFAC mismatch, say, shows in the log). Only the config's own hosts are tried: the web UI can't make rettui connect anywhere else.