fedtail features

Federated, Home, Local. “Home” (home) — the people you follow, without bots; it opens by default. “Local” — your whole server. “Federated” — everything your server knows from all servers. Federated and Local are fetched only while open and have no unread counts: they are for browsing, not for reading to the end. A gap between a fresh page and what was there before is allowed in them — unlike Home, which catches up with no holes (see Catching up with no holes).

Bots in a lane of their own. Posts of accounts with the “bot” tick leave Home for a lane of their own, “Bots”. A bot without the tick goes into lanes.extra_bots: on your server — "nick", on another — "nick@server".

Personal lanes.

• “My posts” (my_posts) — my posts and comments.
• “Direct” (direct) — messages visible to the mentioned only. With lanes.direct_apart = true (the default) they live only here and don’t double up in “Replies to me” and “Mentions”.
• “Replies to me” (replies) — replies to my posts and comments, even if they @ me.
• “Mentions” (mentions) — where I was tagged in someone else’s conversation. lanes.mentions_all = true — show everything that mentions me here, replies too (they’ll be in both lanes).
• “Subscriptions” (subs) — what’s new in threads I’m subscribed to (see Thread subscriptions).
• “Bookmarks” (bookmarks), “My likes” (my_likes, off by default), “Activity” (activity), “Follow requests” (requests) — below, each in its own section.

Splitting “replies to me” from “mentions” is what other clients don’t do: usually it all lands in one notifications lane.

Lists as lanes. The server’s lists are lanes of their own in the “Lists” group. Create, rename, delete, make exclusive — from the menu; add a person — with a right click on their post. fedtail rereads the lists and who is in them every lists.refresh_minutes minutes.

Who is in a list leaves the general lanes. Put a person or a bot in a list — their posts, their boosts and others’ boosts of their posts are read in the list’s lane and disappear from the general lanes, so they don’t clutter them. hide_members: "all" — so with any list; "exclusive" — only with exclusive ones (the server itself takes such people out of Home, fedtail carries that to the other lanes); "off" — don’t take out. Which lanes — lists.hide_in (by default Home, Bots, Federated, Local).

Who is in a list; your own order of lists. Right click on a list on the left: “Who is in it…” — a tab with its people (and those waiting for a follow to be confirmed), each with “Take out of the list”; “Move up” and “Move down” — your own order of lists. Servers keep no order of lists; fedtail remembers it, new ones go to the end.

Into a list — the author or the booster; only people you follow. A boost’s ⋯ menu has two items: “Author to a list (@…)” and “Booster to a list (@…)” — a relay bot is a person too, as far as a list goes. The server takes into lists only people you follow: for the rest the lists in the submenu are dead (they don’t click at all), signed “follow first”, with a “Follow” item. Right click on the “♻ boosted by …” line — the booster’s profile or “To a list”; the name on that line links to the profile.

Into a list right after a follow. The server won’t take into a list someone you don’t follow yet (the request waits with a locked account). fedtail remembers which list you wanted them in and adds them itself as soon as the follow is confirmed.

Hashtag lane, following tags. A click on a #tag opens its lane inside (with ui.links_in_app). Follow a tag — with the button in its lane’s header; the server mixes followed tags into Home, and fedtail offers them first when you type #.

My likes. The posts you liked. The lane is off by default.

Bookmarks. “Bookmark” — with the button under a post (ui.bookmark_button = false moves it into the ⋯ menu), the m key or the command ~ #a3f. The server keeps bookmarks, so they are shared with other clients.

Trends. Popular tags, links and posts, as your server counts them. GoToSocial doesn’t count trends.

An empty live lane says why it’s empty. If the server turned the public timelines off (or gives them to its own users only), Federated and Local don’t hang empty in silence: fedtail says the server turned them off.

Filtering a lane by media and boosts. Over a lane you can leave only text, only pictures, gifs, video or only boosts. It’s a quick look, not a setting: after a restart everything is as it was.

Repeated boosts don’t bring an old post up again. A post comes into a lane once — as itself or with its first boost. A boost of a post this lane has had already, or one already read (in a thread, in another lane), is not shown and not counted as unread; the post stays where it first came. repeat_boosts = true — every boost again, as everyone does. The server (Mastodon) drops a repeat only if the original was among the last ~40 posts of the feed — that’s why old posts kept surfacing again and again.

All / Posts only / New; Feed / Conversations. Over a lane, two switches. “All / Posts only / New”: with all the comments, only top-level posts, or only what’s unread. “Feed / Conversations”: “Conversations” gathers a thread into one card, like conversations on Point. In which lanes “posts only” is on from the start — lanes.posts_only. Remember the choice between runs — feed.remember_choices = true; by default every run starts afresh.

Find in a lane. Ctrl+F finds in the open lane by text, nick, #id and picture captions. It searches its own database and doesn’t ask the server, so it works offline too. Enter, ↓, F3 or Ctrl+F again — to the next match, Shift+Enter — to the previous one.

Find in every lane at once. The “In every lane” tick in the Ctrl+F bar: you remember a phrase but not where you saw it. It searches everything stored in every lane at once (in the sidebar’s order, newest to oldest in each, a post once), the counter says which lane the match is in; the next match opens its lane by itself and loads it down to the post. The tick is remembered.

Finding people, tags and posts. Search on the server: people, tags, posts (as far as the server indexes them), and a link to a post or a profile — the server finds it and fetches it.

A lane of several tags. Type #грузия #georgia -#politics in the search: one lane of all these tags opens — any of them, +#tag must be there, -#tag — without. The “＋ to lanes” button keeps it on the left, in the “Tags” group; it is fetched while open, like Federated. The same lanes can be described in the config, [[lanes.tag_groups]] (name, any, all, none). The server needs a request per tag (GoToSocial reads only one tag at a time), fedtail puts them together itself, without repeats.

Columns side by side. Several lanes on screen at once, in columns. By default — one lane at a time; the ❯ button at the top left (next to ≡ and ↔) turns columns on for now, and the window starts as ui.layout says. A click on a lane on the left adds a column (or scrolls to it), ✕ takes it away, ‹ › move it; the set is remembered. These are the same lanes as in the single view: place, filters and read marks are each their own, and Federated and the other browse lanes keep updating while they stand in a column.

Collections (Mastodon 4.6). Shared sets of accounts. Coming once GoToSocial has them.

A thread as a tree, comments numbered. A thread opens as a tree: every reply under what it answers, every comment numbered /1, /2, /2/1, as on Point and Juick. The command line can address a comment by its number.

Over a reply — what it answers. Over a reply in a lane, a strip “↪ in reply to…” with the start of the original post; a click opens the whole thread. No reply in a lane hangs as a scrap.

A whole thread: replies from the author’s server. Your server knows only the replies that reached it, so other people’s threads have holes. Open a thread — fedtail reads the list of replies straight from the author’s server and asks your server to fetch what’s missing; the thread grows by itself a couple of seconds later. Requests to other servers go without your token. false — make do with what your own server knows.

A thread grows when Mastodon has gathered the replies. Mastodon 4.5+ gathers missing replies itself and says when it’s done; fedtail waits for that signal and rereads the thread.

Thread subscriptions, as on Point. The server tells you only of replies that mention you: if two people answer each other under your post, you won’t know. fedtail itself rereads the threads you’re subscribed to every subs.interval_minutes minutes and puts what’s new into the “Subscriptions” lane. Subscribe — in a post’s ⋯ menu, with the button in the thread’s header or the command S #a3f (U #a3f — unsubscribe). subs.auto — what to subscribe to by itself: "posts" — your own posts, "comments" — threads you comment in. A thread quiet for subs.active_days days is not checked any more; one round checks at most subs.max_threads threads. Replies to you come to “Replies to me” anyway; subs.replies_to_me = true — show them in “Subscriptions” too. Unsubscribing mutes the thread’s mentions as well (replies there tag everyone in it by themselves); subs.leave_mutes = false — leave “Subscriptions” only.

Mute a thread. Notifications from the thread stop coming and its subscription goes. A server that can do it remembers it for all clients; where it can’t (GoToSocial), fedtail mutes the thread itself: its mentions are dropped as they come — even replies to posts of the thread it never saw. The item in a post’s ⋯ menu is always there.

Long texts and events. Articles from WriteFreely, Ghost, Plume, Lemmy posts, Mobilizon events. The Mastodon API flattens them into an ordinary post with the text cut. The ⋯ menu of such a post has “📄 Read it whole”: fedtail takes the full text straight from the author’s server over ActivityPub, for an event — also the time and the place.

Oldest on top, nothing jumps. feed.order = "oldest_first" — oldest on top, you read downwards, like RSS or Point ("newest_first" — as everyone does). feed.start_at = "first_unread" — open a lane and you stand at the first unread ("newest" — at the freshest). feed.on_new = "keep_position" — new posts come and the place doesn’t move, only the counter grows ("jump_to_newest" — jump to the new).

Catching up with no holes. Lanes meant to be read to the end catch up forward from the last known post, page by page (page_size posts a request, up to catch_up_limit a poll — the rest on the next one). So the local copy has no holes and you can read strictly in order. The “load what’s missing” button other clients keep fixing (Fedilab in 2026 — half a dozen fixes about holes and jumps, some on GoToSocial) isn’t needed here.

When a post counts as read. "on_scroll" — when you’ve scrolled past the whole post; "on_open" — the whole lane as soon as you open it; "manual" — by hand only: “All read” over the lane, “Mark read” and “Read up to here” (this one and everything older) in the ⋯ menu. In the manual mode a lane always waits exactly where you stopped, even reading one post at a time. read.read_button = true — a ✓ button under each unread post. The menu items work in any mode.

Your own posts are always read. A post you wrote is read, wherever it came from: from Tusky at night, through a thread, fetched after a restart.

The first run doesn’t start with a pile. At the very first run, everything fetched counts as read.

The reading place is shared with other clients. Read Home or mentions to the end on the phone — here it’s read too, and the other way round. Works with Mastodon, GoToSocial, Akkoma — if that client tells the server its place: Mastodon’s web, Ivory, Phanpy do; Tusky keeps its place in Home to itself and shares only notifications. false — read marks live in fedtail only.

Cards are built around the reading place. When a lane opens, build_at_once cards are built around where you read; the rest — as you scroll near an edge, and far behind they are let go (more than three build_at_once — back to one behind and two ahead). What you read doesn’t move; a filter and “unread only” also build only around the reading place. At most render_limit latest posts are kept on screen, older ones with the “older” button. 0 in build_at_once — build everything at once (on hundreds of posts that takes seconds).

Esc draws a curtain instead of closing the window. Esc closes what’s on top (a picture, the search), and the last Esc with ui.esc = "curtain" draws a curtain over all lanes: the window stays, the counts on the left, nothing on the right, and nothing is marked read — open it in the morning and the new has piled up. "tray" — off to the tray, "off" — nothing. What to start with — ui.start_lane: "none" (the curtain, Enter opens the last one), "last" or a lane’s name.

Arts mode. Everything as the author posted it, no nannying. Turns on at once: content warnings (CW) open, “sensitive” pictures without a cover, server filters neither hide nor fold posts, no “Report” item. Your own mutes and blocks work as usual; what the server itself cuts off (domain blocks) never reaches a client — that can’t be got round. false — everything as everyone has it, and then each of these is set on its own (ui.expand_cw, feed.sensitive_media). Named after @arts — the founder of Point.im and the author of its rules. The principle comes from there too: on a grown-up site grown-ups sort things out themselves. Anyone can be told where to go, an admin too — and the admin can say the same back.

Content warnings (CW). true — text and pictures under a CW open at once; false — folded, opened with the “show” button.

Open every CW in a thread at once. Not needed with arts mode on. If people who turned it off ask — a button in the thread’s header.

Sensitive pictures. Pictures the author marked sensitive (without a CW): "hide" — under a cover, a click shows them; "show" — seen at once. Under a CW they are hidden together with the text anyway.

Link cards. The title, description and picture of the page a post links to (the server collects them): "full" — with the picture, "text" — a line or two, "off" — not shown. A post with its own pictures has no card.

Servers’ emoji as pictures. :blobcat: and the rest — as pictures in posts and names. false — leave them as text and don’t fetch the pictures.

Quotes: showing them. A post inside a post (Mastodon 4.5+, Akkoma, Misskey and others): "card" — framed inside, "link" — a line with a link, "off" — as the server sent it (usually “RE: link”).

Polls: seeing and voting. Options, percentages, the deadline; voting for one or several options, as the author set.

Poll results without voting. The “Results” button next to “Vote” — look without voting.

Edit history. An edited post is marked so and has all its earlier versions.

Translation by the server. “Translate” in the ⋯ menu of a post in another language — if your server can (Mastodon with DeepL or LibreTranslate). The translation is right in the card, with an “original” button.

Emoji reactions. Reactions from Akkoma, Pleroma, Misskey and their forks show under the post. Adding your own isn’t possible yet; GoToSocial doesn’t support them.

Who liked and boosted. Lists of people at the counters. If your server doesn’t know everyone, the rest is read from the author’s server.

Honest counters. Your server knows only the likes and boosts that reached it, so the numbers on other people’s posts are low. With honest_counters = true, when a thread opens fedtail asks the author’s server for the real numbers — without a token, but with your IP. If that server won’t give numbers without a login and you have other accounts (profiles), counters_via_accounts lets it ask as them: the author’s server, if you have an account there, or a server that already has the post. Each account’s token goes only to its own server.

Who quoted my post. The list of quotes of my post and “take my post out of this quote”.

Folding hashtag padding. A paragraph of nothing but hashtags (more than three) in a lane folds into the first three and “… +N” in small type; in an open thread it’s whole, but small too. Hashtags inside the text aren’t touched.

Boost carousel. Boosts in a row — as one strip scrolled sideways (as in Phanpy). Won’t do: sideways is awkward to read, and it fits badly with “nothing jumps” and read marks. The same job is done by the “Boosts” tick in the filter, “without their boosts” on a profile and relays in a list of their own.

Labels on the card. Next to the date: “old, N days” — a post older than feed.old_days (30) days; such posts come from someone’s outbox or an old thread; “[bot]” — on bots. There is no “from another server” label yet.

Picture viewer. A click on a picture — its own viewer ("internal": ← → to flip, Esc to close) or the browser ("browser"). Small pictures are enlarged to the window at most image_upscale times. The height of a single picture in a lane — image_height.

Picture grid. Several pictures in a post: "natural" — each whole, its own shape; "square" — an even grid of squares cut around the author’s focus point. A single picture is never cut.

Picture descriptions (alt). "tooltip" — on hover; "caption" — also as a caption under the pictures. Descriptions are found by Ctrl+F.

Video, audio, gifs inside the window. A video plays over the window (Space — pause, ← → — seek, M — sound, O — to the browser, Esc — close), audio — with a player in the card. Needs QtMultimedia (Debian: python3-pyside6.qtmultimedia python3-pyside6.qtmultimediawidgets); without it — a still frame with ▶ and the browser. Mastodon’s gifs (short silent videos): "play" — loop in the card while it’s on screen (at most three at once), "click" — a still frame, a click plays it over the window.

Save a picture, video, gif. The ⤓ button, the S key in the viewer, a right click on a picture in a lane. "" — into the desktop’s Downloads.

Pictures and video ahead of time, a disk cache. As soon as a poll brings new posts, their pictures are fetched to disk by background workers of their own — open a lane and everything is there. "previews" (the default) — previews (of videos too), avatars and link pictures; "all" — also originals, the videos themselves and gifs (videos one at a time, up to 300 MB each); "off" — only when a post is on screen. The picture cache keeps within image_disk_mb (1 GB), videos — in their own folder, video_disk_mb (10 GB); over the limit go the ones not opened the longest. A video opened once plays from disk the next time.

Memory for pictures. Decoded pictures are held in memory up to image_cache_mb MB, the oldest thrown out first (reread from disk at once). image_decode = "box" — decode to the size of the frame, minding the screen’s density: several times less memory; "full" — up to 1200 pixels on the longer side, sharper when the window is stretched.

Your own and other people’s profiles. The header, bio, fields, counts, posts; “followed by people you follow” (familiar_followers); follows and followers.

Pinned posts. At the top of a profile, marked 📌. false — the profile simply in time order.

Featured tags and recommended people. “Often writes about: #tags” and whom the person recommends (Mastodon 4.4+).

A little-known person’s profile — from their server. If your server knows almost nothing about a person from another server, fedtail reads their latest public posts straight from there (remote_posts of them, at most 40) and asks your server to fetch them. Without a token; servers that require signed requests simply give nothing.

Posts older than my server knows. Your server knows a person’s posts only from the moment someone on it followed them. fedtail pages through older ones straight from the author’s server.

Followers and follows from the person’s server. At the bottom of such lists — a “more from their server” button: fedtail reads them there and finds these people through your server.

“Following since …”. Servers don’t keep the day you followed someone. When you follow through fedtail, the date is written as the last line of your private note on the person ([fedtail followed 2026-10-18]): it’s seen from any device and in other clients. In fedtail the line is hidden and kept when the note is edited. false — remember it locally only.

The person has moved. A moved person’s profile has a “📦 Moved to @new” banner with “Open” and “Follow there” buttons.

The author’s server software. fedtail asks the person’s server for its nodeinfo (Mastodon, GoToSocial, Akkoma, Misskey, Lemmy…) and writes “🖥 GoToSocial 0.17.3” in the profile. The answer is kept a week per server.

What my server can do. A score of “show me one” requests (nothing changes on the server), a few seconds in the background — the window doesn’t freeze. Each feature gets an answer: yes, no, there but closed to me, unclear; limits (characters, attachments, poll options) as numbers. What can’t be asked without changing something (dismissing one notification, muting a thread) is told from what server this is. The last check is kept and shown at once; the answers also tell fedtail which buttons to show.

The compose panel and drafts. ui.compose = "inline" — a panel inside the main window (the keyboard layout isn’t reset: KDE keeps it per window); "window" — a window of its own. The panel’s size — in percent of the window (compose_size), the ⤡ button switches normal and big. Drafts are saved as you type and survive closing.

Visibility: private by default, a reply never wider than the post. A new post goes to followers by default ("private"); "server" — as set on the server. A reply is never more public than the original post.

Markdown. "auto" — ask the server; GoToSocial and Akkoma understand Markdown, vanilla Mastodon doesn’t.

Preview before sending. The “👁 Preview” button in the panel: the Markdown already rendered (if the server understands it), the CW, visibility, language, each part of a chain, how many pictures; “Send” or “Edit” from there.

Content warning (CW). The CW field is open at once or hidden behind the “⚠ Warning” button. In a reply, the original post’s CW is filled in by itself.

Pictures: drag, paste, description, focus. Drag a file in or paste from the clipboard. A double click on a picture — the description and the focus point. A picture without a description — before sending, ask “Describe” or “Send as is”. Marking pictures sensitive — with a tick.

Shrinking pictures to the server’s limit. The server says what picture it takes (in pixels and bytes). Bigger — before the upload fedtail shrinks a copy to the pixel limit and recompresses it as JPEG (with transparency — PNG) under the byte limit, instead of being refused. Your file isn’t touched, gifs aren’t flattened. post.resize_images = false — as is.

Completing #tags, @nicks, :emoji:. #ge — first the tags you follow, then the frequent ones in the lanes. @ar — first the people seen most in the lanes, then those the server finds. :co — the server’s emoji, Tab or Enter puts it in.

CamelCase hint for hashtags. A hashtag in one case (#georgianews) gets a hint: screen readers read #GeorgiaNews word by word.

The post’s language. The default language and a list in the post window (any ISO 639 code; “Another language…” adds to the list for good).

Call someone into a thread. A post’s ⋯ menu → “Call into the thread…”: a reply to this post with only “@” in it so far and the people list open at once — pick whom (several are fine), write a couple of words. The person gets a notification, a click — and the thread is open on their side, on their server, ready for a reply; no scary links with service ids. The thread’s other participants aren’t mentioned, the call has its own draft. If the thread isn’t public, the person called sees your reply, and the rest only as far as they could anyway. The same from the command line: #a3f @whom take a look.

Reply with quotes, piece by piece. A post’s ⋯ menu → “Reply with quote”: a reply with the post’s text already in it as a quote (> , the leading mentions left out), or only what’s selected in the post. A right click on a selection → “Quote in reply”. With a reply to this post already open, the quote goes where its cursor is, an empty line after it: select a sentence, quote, answer, select the next one — and so on through the post. The quote’s line start is post.quote_prefix; "" — no such items.

Copy the handle @user@server. The “Copy handle” button on a profile, the “Copy handle @…” item in a post’s ⋯ menu (the author and, for a boost, the booster) and in the menu of the “♻ boosted by” line. Always the full @user@server: people from your server come as just user, your server’s name is added — any client can find and mention a person by such a handle.

Quoting a post; who may quote mine. “Quote” in the ⋯ menu of a post its author lets quote. Who may quote my new posts: "public", "followers", "nobody" or "" — as on the server.

Who may reply, boost, like (GoToSocial). "everyone", "followers" (and the mentioned), "following" (and the mentioned), "mentioned", "me" or "" — as in the account’s settings. Not sent to other servers.

A scheduled post. The “⏰ Later” button: the post waits on the server, even if fedtail is closed. The list of waiting ones — ≡ → “Scheduled”.

Delete and redraft. An item in the ⋯ menu of your own post: the post is deleted, and its text (as typed), CW, visibility, language and what it answered open in the panel as a new draft; the server deletes the pictures with the post, you add them again — for servers without editing and for when an edit won’t do (changing visibility).

A thread as a chain. A line of nothing but --- splits the text into posts: they go at once, each a reply to the one before, with the same visibility, CW and language; pictures and the poll go with the first. The character counter counts each part on its own. post.chain = false — --- stays text.

A command line as on Point. At the bottom of the window (Ctrl+L): #a3f — open, #a3f text — reply, S/U #a3f — subscribe to a thread, S/U @nick — follow a person, ! — boost, ~ — bookmark, D — delete your own, @nick — profile, ? — help. Plain text without a command — a new post (post.plain_posts = false — commands only, no accidental posts).

Follows and follow requests. Follow, unfollow, accept or reject a follow request (the “Follow requests” lane).

Hide a person’s boosts; the languages of a follow. On the profile of someone you follow: “♻ without their boosts” and “🌐 languages” — only their posts in these languages. The server keeps it, so it works in every client.

Mute, block, word filters. Word filters are the server’s, v2: where they apply, for how long, hide or fold. All this — in the ≡ menu → “For the tender and sensitive”: word filters, muted, blocked, blocked servers and filtered notifications; with ui.arts_mode, a line on top says the server’s filters don’t apply there.

Block a whole server. Nobody from there in any lane, follows across the border are cut.

Report to the moderators. About a person from another server — a “forward to their server too” tick (they won’t learn who reported). In arts mode the item isn’t there.

About the server. The description, rules, privacy policy.

Your profile. Name, bio, fields, avatar, header.

Desktop notifications with privacy levels. Which lanes to notify about — notify.lanes (the same names as in [lanes]; "lists" — all lists, "list:Friends" — one, "all" — everything); which never — notify.except (a blacklist over lanes, say with ["all"]). privacy: "full" — who and what, "sender" — only who (fine to read with others around), "count" — only how many. About the lane in front of your eyes it keeps quiet by default (when_focused). backend: "auto" (notify-send, else the tray), "desktop", "tray".

Activity: likes, boosts, follows. The “Activity” lane: who liked, boosted, followed, a poll ended, a post you boosted was edited, a new post under a bell — with the time of each event. ["all"] — everything there is and what will be added.

Approve a reply, like, boost (GoToSocial). Interaction requests waiting for approval under your who-may-do-what settings come with “Approve” and “Reject” buttons.

Notifications from strangers apart. Mastodon holds back mentions from unknown and new accounts until you allow them. ≡ → “For the tender and sensitive” → “Filtered notifications…”: who waits, “Let in” / “Dismiss”, what to filter. "remind" — also a line at start, "menu" — in the menu only, "off" — not at all.

Severed relationships and moderators’ warnings. When your server blocks another one (or the other way round) and your follows are cut, Mastodon sends a notification with the list of what was lost; moderators may send a warning. fedtail shows them in “Activity” (activity.server_notices).

Server announcements. "banner" — a strip over the lane until you press “Got it” (the server remembers that for other clients too); reactions to announcements. "off" — not shown.

The unread number on the icon. In the tray and on the task bar button (KDE: needs the entry from --install-desktop and python3-pyside6.qtdbus). Which lanes to count — a list, as for notifications: "lists" — all lists, "list:Friends" — one, "all" — everything, plus icon_count_except — what not to count. The icon itself — an opossum holding its own tail (app_icon = "possum", also in the menu and in About), or the drawn thread bubble ("bubble"), which themed_icon paints in the theme’s colours.

Profiles and the switcher. One profile — one account with its own config, theme, database and window. A right click on the avatar (or ≡ → “Account and server”) — the list, “My profile”, “About the server…” (it has the “Edit profile” button), “Add an account…”; switch_closes — whether to close the current window when switching. Which profile and account this is — on the left of the status bar: “default: @nick@server ★”.

The main profile ★. The one started without --profile and from the “fedtail” menu entry. It isn’t a folder with a special name but a mark — the main-profile file next to the profile folders; without the mark the main one is default. “Make it the main one” in the accounts menu moves it; in the list (and in --profiles) the main one is marked ★.

Log in again, log out. Both are in the accounts menu, both ask first. “Log in again…” — for a revoked token or new permissions: the old token lives until you’re in, cancelling changes nothing, and you can log in this way only to the same account (another one — “Add an account…”). “Log out…” deletes the token (read marks, drafts and the config stay); if that was the main profile, ★ goes to another one you’re logged in to and the window switches to it; if there are none — the login window. In the window of all accounts both items are unavailable.

All accounts in one window. Lanes of the same name merge, posts of other accounts are marked “→ @nick” — a reply, a like and a boost go from the account that received the post. Lists — lanes of their own. ["all"], profile names or [] — as chosen in the menu.

An account’s colour in the shared window. A coloured strip or mark on the posts that came to each account — to see in a merged window whose it is without reading “→ @nick”.

Acting as another account. Like, boost or reply not as the account that received the post: in the shared window, a post’s ⋯ menu has “From another account”: fedtail finds the post through that account’s server and does it from there; a reply opens in the editor as that account.

Themes as files. Built in: system (as in KDE), terminal, juick, juick-classic, bnw, point, night, contrast (for weak eyes), pink, nord, solarized, paper, debug (for debugging: each state of a post — unread, the j/k cursor, found, “not seen whole yet, not read yet”, the keyboard focus — in a loud frame of its own; shape.debug = true turns the same on in any theme of your own). Your own — a file in ~/.config/fedtail/themes/. A theme sets the card’s layout too: the avatar’s shape (avatar_shape), the header in a line or the name over the date (card_header = "stacked"), where the #id stands (short_id: by the name or under the post with the reply count), which side the buttons are on (actions_align), the line between posts (rule: solid or dashed), a hatched band under the titles of the lane and the post window (header_stripes) and a dark strip over it (header_bar), the colour of the main buttons, of the lane’s title strip and of names. A theme sets the look of the whole app, not only colours; that’s why separate card templates aren’t needed (see Won’t do). The font — ui.font, over the theme’s (where the system one reads badly); a theme can bring fonts of its own ([font] files), and .ttf/.otf files in ~/.config/fedtail/fonts/ are picked up without installing them system-wide. The width of the posts column — max_width (0 — the full width; the ↔ button at the top left switches it for now and remembers the choice until the next start), labels on buttons — actions.

The config as a file in chapters. The program only reads the config. A new version brought settings — --update-config adds them to the right chapters with explanations; --rebuild-config rebuilds the file anew, keeping your values. A value written by hand stays yours when the default changes.

The settings reference. The config reference, built from the example configs: every setting with its description, choices and default, in tables by chapter, in Russian and in English. A test makes sure it keeps up with the files.

Window, tray, keys. The cross hides to the tray. j/k — through posts, r — reply, f — like, b — boost, m — bookmark, o/Enter — the thread. post_keys = false — the letters do nothing.

Links to posts and profiles — inside. @mentions, #tags and links to fediverse posts and profiles open in fedtail. Not found — the browser. Only web addresses go outside (and mailto:, xmpp:, gemini://, magnet:): fedtail won’t open a link to a file or a network share from someone’s post.

Open a link in the running fedtail. fedtail open URL from a terminal or a browser opens a post or a profile in the window already open (or starts it and opens it there). --install-desktop makes fedtail the handler of web+ap:// links — the “open in your app” buttons on servers’ pages.

Open for days without bloating. A lane not opened for unload_hidden_minutes minutes lets its cards go from memory; the one open is never unloaded. fedtail gives the freed memory back to the system (trim_memory: otherwise glibc keeps the peak after a night of lanes and pictures).

Polling the server and the live stream. A poll every interval_seconds (at least 30). The live stream ("auto", if the server offers it) wakes the poll at once, but not more often than every stream_gap_seconds. The stream only wakes, so if it drops (a laptop asleep, a proxy) nothing is lost.

Errors in plain words and without spam. A server behind a proxy is down — instead of Cloudflare’s HTML page one line “Bad Gateway — the server is down or not answering”; the same error of every poll is shown and logged once, again only when it changes or ten minutes later.

A detailed log for bug reports. In the debugging mode (mode = "auto" — on in development versions, off in releases): a log of requests, polls, actions (without the posts’ texts), errors with tracebacks, memory and thread stats every stats_minutes, a freeze watchdog (watchdog_seconds, stall_ms), slow requests, memory growth. crash.log — the stacks on a crash, kill -USR1 — the stacks on demand. The new version deletes the old version’s logs itself. --bug-report packs two days of it, without the token and the database. In detail — DEBUGGING.md.

Federation status: how my server is doing and what fails. ≡ → “Debugging” → “Federation status”: problems that don’t depend on the client. My server — what it runs, how many answers and how many with errors, how fast it answers (typical and slow ones), polling (the last good one, how many times it failed and why), the live stream (open since when, how many times it dropped). What the server can’t do (asked and got “no”). Who waits to go into a list: the name linked to the profile (opens in a tab, with “Follow”) and why they wait — a request unanswered, no follow (refused or withdrawn), or followed and going in by itself. What fails on my server and on other servers — grouped by request (ids folded: /api/v1/lists/:id/accounts), how many times, when last, and what it most likely means (“deleted on that server”, “won’t give strangers anything without a signature”, “lists take only people you follow”…). Other servers — who answered how much and with what errors. The window updates by itself while open; “Copy” — as text for an issue, “Count anew” — start from zero. For the window only your own server is asked — who those waiting in lists are; the rest is what this run saw. Addresses without parameters, no tokens.

Leak hunting: trends, an object census, memory snapshots. For days-long runs. With every stats line — a trend line: memory, Python objects, widgets, cards, pictures, threads, files — how many at start, how many now, how many an hour. Something that grew on each of the last leak_samples checks (12 — an hour) and by more than crumbs — a possible leak warning with the numbers; the first half hour doesn’t count. In the debugging mode — a census: which Python objects and Qt widgets were added since the last check and since the start (object_census). tracemalloc = true — memory tracing from the start; a snapshot — ≡ → “Debugging” → “Memory snapshot”: a file with who holds the most and what grew, by line of code. There too: “What grows: stats and census now”, “Give free memory back to the system”, tracing on/off. The session’s last line — session summary: hours, memory, peak, freezes, polls. How to leave it overnight — DEBUGGING.md.

The database doesn’t grow for ever: cleanup and a size budget. Every gc_hours (and at the first poll after start) posts nothing points at are forgotten: no lane, followed thread, “Activity” entry or reply draft. My own posts stay, and so do the boosted post, the quoted one and the parents up the whole thread of every post that stays, so visible replies aren’t fetched again. Whatever was stored recently (an open thread, a profile) lives grace_hours more. “Activity” keeps the latest keep_activity entries. The file really shrinks (incremental vacuum). If the database is still over max_mb (1 GB by default), lanes get 30 % shorter until it fits (never below 300) and grow back to keep_per_lane once there is room. Short ids (#a3f) are never forgotten. What was forgotten and how big the database is — the storage gc line in the log.

Screen readers. Picture descriptions and button names for screen readers are there, but the interface hasn’t been tried live with Orca.

Interface language. "auto" (from LANG), "ru", "en".

Help inside, in two languages. A panel in the main window, like the compose panel: the contents on the left, search through the whole help, Back and Forward. Short, by section, and at the end of each — “In detail →” into the full feature list and the settings reference: they are right here and work offline. No shortcut on purpose — F1 is next to Esc.

“What’s this?”: a longer hint about any button. Turn it on, and hovering shows a longer hint instead of the short one: what the button does, which config key changes it and which help section says more. The same menu item turns it off.

Commands in a terminal. fedtail lanes, fedtail show replies -n 20, fedtail tail (the new as it comes), fedtail post "text", fedtail post --reply a3f "text", fedtail read replies. The same profile, database and read marks as the window; works without Qt.

A terminal interface (Textual). Lanes on the left, posts on the right, the command line at the bottom. The same keys, x — the lane is read, : — the command line. Lanes — [ / ], digits 1…9, h — into the lane list (j / k there), l — back to the posts, Tab — to and fro. “Activity” and “Follow requests” have rows of their own (in requests a — accept, d — reject). Pictures are drawn with half blocks: the first one small right in the lane (tui.pictures, tui.picture_rows), v — all of them full screen, ← / → between them, o — the original in the browser; needs Pillow (python3-pil) and a true colour terminal. Works over ssh. Needs python3-textual.

Web on localhost. fedtail in a browser tab: lanes, threads as trees, profiles, a “Write” button (content warning, who sees it, language, drafts), pictures in a grid with a viewer, video and audio, polls with voting, link cards, quotes, custom emoji, “More” at a lane’s end, the Point command line; on a phone the lanes slide in from the side, light and dark follow the system. At start a one-time link (15 minutes) is printed; the browser gets a key from the profile’s folder in a cookie (web.key; delete it and every browser and every old link with the key is out). host = "0.0.0.0" — from the phone on the home network too; no encryption, for your own network only. The ≡ menu (write, my profile, refresh, all read, help, keys, about) and a post’s ⋯ menu (reply with quote, subscribe / leave / mute the thread, copy the link, delete my post). A reply shows the whole post: select a piece and “❝ Quote in reply” puts it where the cursor is. The viewer goes through a post’s pictures with ← / →.

GTK4 + libadwaita. To look native in GNOME and other GTK desktops.

Toga (BeeWare). Native widgets of Windows, macOS, GTK, Android from one code. To try out.