Go to the first, previous, next, last section, table of contents.

# The Summary Buffer

A line for each article is displayed in the summary buffer. You can move around, read articles, post articles and reply to articles.

- Summary Buffer Format: Deciding how the summary buffer is to look.
- Summary Maneuvering: Moving around the summary buffer.
- Choosing Articles: Reading articles.
- Paging the Article: Scrolling the current article.
- Reply Followup and Post: Posting articles.
- Canceling and Superseding: "Whoops, I shouldn't have called him that."
- Marking Articles: Marking articles as read, expirable, etc.
- Limiting: You can limit the summary buffer.
- Threading: How threads are made.
- Sorting: How articles and threads are sorted.
- Asynchronous Fetching: Gnus might be able to pre-fetch articles.
- Article Caching: You may store articles in a cache.
- Persistent Articles: Making articles expiry-resistant.
- Article Backlog: Having already read articles hang around.
- Saving Articles: Ways of customizing article saving.
- Decoding Articles: Gnus can treat series of (uu)encoded articles.
- Article Treatment: The article buffer can be mangled at will.
- Summary Sorting: Sorting the summary buffer in various ways.
- Finding the Parent: No child support? Get the parent.
- Alternative Approaches: Reading using non-default summaries.
- Tree Display: A more visual display of threads.
- Mail Group Commands: Some commands can only be used in mail groups.
- Various Summary Stuff: What didn't fit anywhere else.
- Exiting the Summary Buffer: Returning to the Group buffer.

## Summary Buffer Format

- Summary Buffer Lines: You can specify how summary lines should look.
- Summary Buffer Mode Line: You can say how the mode line should look.
- Summary Highlighting: Making the summary buffer all pretty and nice.

Gnus will use the value of the `gnus-extract-address-components` variable as a function for getting the name and address parts of a `From` header. Two pre-defined function exist: `gnus-extract-address-components`, which is the default, quite fast, and too simplistic solution; and `mail-extract-address-components`, which works very nicely, but is slower. The default function will return the wrong answer in 5% of the cases. If this is unacceptable to you, use the other function instead.

`gnus-summary-same-subject` is a string indicating that the current article has the same subject as the previous. This string will be used with those specs that require it. The default is ``'`.

### Summary Buffer Lines

You can change the format of the lines in the summary buffer by changing the `gnus-summary-line-format` variable. It works along the same lines a a normal `format` string, with some extensions.

The default string is ``%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n'`.

The following format specification characters are understood:

``N'`
  Article number.
``S'`
  Subject string.
``s'`
  Subject if the article is the root, `gnus-summary-same-subject` otherwise.
``F'`
  Full `From` line.
``n'`
  The name (from the `From` header).
``a'`
  The name (from the `From` header). This differs from the `n` spec in that it uses `gnus-extract-address-components`, which is slower, but may be more thorough.
``A'`
  The address (from the `From` header). This works the same way as the `a` spec.
``L'`
  Number of lines in the article.
``c'`
  Number of characters in the article.
``I'`
  Indentation based on thread level (see section Customizing Threading).
``T'`
  Nothing if the article is a root and lots of spaces if it isn't (it pushes everything after it off the screen).
``\['`
  Opening bracket, which is normally ``\['`, but can also be ``<'` for adopted articles.
``\]'`
  Closing bracket, which is normally ``\]'`, but can also be ``>'` for adopted articles.
``>'`
  One space for each thread level.
``<'`
  Twenty minus thread level spaces.
``U'`
  Unread.
``R'`
  Replied.
``i'`
  Score as a number.
``z'`
  Zcore, ``+'` if above the default level and ``-'` if below the default level. If the difference between `gnus-summary-default-level` and the score is less than `gnus-summary-zcore-fuzz`, this spec will not be used.
``V'`
  Total thread score.
``x'`
  `Xref`.
``D'`
  `Date`.
``M'`
  `Message-ID`.
``r'`
  `References`.
``t'`
  Number of articles in the current sub-thread. Using this spec will slow down summary buffer generation somewhat.
``e'`
  A single character will be displayed if the article has any children.
``u'`
  User defined specifier. The next character in the format string should be a letter. GNUS will call the function `gnus-user-format-function-```X'`, where ``X'` is the letter following ``%u'`. The function will be passed the current header as argument. The function should return a string, which will be inserted into the summary just like information from any other summary specifier.

The ``%U'` (status), ``%R'` (replied) and ``%z'` (zcore) specs have to be handled with care. For reasons of efficiency, Gnus will compute what column these characters will end up in, and "hard-code" that. This means that it is illegal to have these specs after a variable-length spec. Well, you might not be arrested, but your summary buffer will look strange, which is bad enough.

The smart choice is to have these specs as far to the left as possible. (Isn't that the case with everything, though? But I digress.)

This restriction may disappear in later versions of Gnus.

### Summary Buffer Mode Line

You can also change the format of the summary mode bar. Set `gnus-summary-mode-line-format` to whatever you like. Here are the elements you can play with:

``G'`
  Group name.
``p'`
  Unprefixed group name.
``A'`
  Current article number.
``V'`
  Gnus version.
``U'`
  Number of unread articles in this group.
``e'`
  Number of unselected articles in this group.
``Z'`
  A string with the number of unread and unselected articles represented either as ``<%U(+%u) more>'` if there are both unread and unselected articles, and just as ``<%U more>'` if there are just unread articles and no unselected ones.
``g'`
  Shortish group name. For instance, ``rec.arts.anime'` will be shortened to ``r.a.anime'`.
``S'`
  Subject of the current article.
``u'`
  Used-defined spec.
``s'`
  Name of the current score file.
``d'`
  Number of dormant articles.
``t'`
  Number of ticked articles.
``r'`
  Number of articles that have been marked as read in this session.
``E'`
  Number of articles expunged by the score files.

### Summary Highlighting

`gnus-visual-mark-article-hook`
  This hook is run after selecting an article. It is meant to be used for highlighting the article in some way. It is not run if `gnus-visual` is `nil`.
`gnus-summary-update-hook`
  This hook is called when a summary line is changed. It is not run if `gnus-visual` is `nil`.
`gnus-summary-selected-face`
  This is the face (or font as some people call it) that is used to highlight the current article in the summary buffer.
`gnus-summary-highlight`
  Summary lines are highlighted according to this variable, which is a list where the elements are on the format `(FORM . FACE)`. If you would, for instance, like ticked articles to be italic and high-scored articles to be bold, you could set this variable to something like

      (((eq mark gnus-ticked-mark) . italic)
       ((> score default) . bold))

  As you may have guessed, if FORM returns a non-`nil` value, FACE will be applied to the line.

## Summary Maneuvering

All the straight movement commands understand the numeric prefix and behave pretty much as you'd expect.

None of these commands select articles.

`G M-n`
`M-n`
  Go to the next summary line of an unread article (`gnus-summary-next-unread-subject`).
`G M-p`
`M-p`
  Go to the previous summary line of an unread article (`gnus-summary-prev-unread-subject`).
`G j`
`j`
  Ask for an article number and then go that article (`gnus-summary-goto-article`).
`G g`
  Ask for an article number and then go the summary line of that article (`gnus-summary-goto-subject`).

If Gnus asks you to press a key to confirm going to the next group, you can use the `C-n` and `C-p` keys to move around the group buffer, searching for the next group to read without actually returning to the group buffer.

Variables related to summary movement:

`gnus-auto-select-next`
  If you are at the end of the group and issue one of the movement commands, Gnus will offer to go to the next group. If this variable is `t` and the next group is empty, Gnus will exit summary mode and return to the group buffer. If this variable is neither `t` nor `nil`, Gnus will select the next group, no matter whether it has any unread articles or not. As a special case, if this variable is `quietly`, Gnus will select the next group without asking for confirmation. If this variable is `almost-quietly`, the same will happen only if you are located on the last article in the group. Finally, if this variable is `slightly-quietly`, the `Z n` command will go to the next group without confirmation. Also see section Group Levels.
`gnus-auto-select-same`
  If non-`nil`, all the movement commands will try to go to the next article with the same subject as the current. This variable is not particularly useful if you use a threaded display.
`gnus-summary-check-current`
  If non-`nil`, all the "unread" movement commands will not proceed to the next (or previous) article if the current article is unread. Instead, they will choose the current article.
`gnus-auto-center-summary`
  If non-`nil`, Gnus will keep the point in the summary buffer centered at all times. This makes things quite tidy, but if you have a slow network connection, or simply do not like this un-Emacsism, you can set this variable to `nil` to get the normal Emacs scrolling action. This will also inhibit horizontal re-centering of the summary buffer, which might make it more inconvenient to read extremely long threads.

## Choosing Articles

None of the following movement commands understand the numeric prefix, and they all select and display an article.

`SPACE`
  Select the current article, or, if that one's read already, the next unread article (`gnus-summary-next-page`).
`G n`
`n`
  Go to next unread article (`gnus-summary-next-unread-article`).
`G p`
`p`
  Go to previous unread article (`gnus-summary-prev-unread-article`).
`G N`
`N`
  Go to the next article (`gnus-summary-next-article`).
`G P`
`P`
  Go to the previous article (`gnus-summary-prev-article`).
`G C-n`
  Go to the next article with the same subject (`gnus-summary-next-same-subject`).
`G C-p`
  Go to the previous article with the same subject (`gnus-summary-prev-same-subject`).
`G f`
`.`
  Go to the first unread article (`gnus-summary-first-unread-article`).
`G b`
`,`
  Go to the article with the highest score (`gnus-summary-best-unread-article`).
`G l`
`l`
  Go to the previous article read (`gnus-summary-goto-last-article`).
`G p`
  Pop an article off the summary history and go to this article (`gnus-summary-pop-article`). This command differs from the command above in that you can pop as many previous articles off the history as you like.

Some variables that are relevant for moving and selecting articles:

`gnus-auto-extend-newsgroup`
  All the movement commands will try to go to the previous (or next) article, even if that article isn't displayed in the Summary buffer if this variable is non-`nil`. Gnus will then fetch the article from the server and display it in the article buffer.
`gnus-select-article-hook`
  This hook is called whenever an article is selected. By default it exposes any threads hidden under the selected article.
`gnus-mark-article-hook`
  This hook is called whenever an article is selected. It is intended to be used for marking articles as read. The default value is `gnus-summary-mark-read-and-unread-as-read`, and will change the mark of almost any article you read to `gnus-unread-mark`. The only articles not affected by this function are ticked, dormant, and expirable articles. If you'd instead like to just have unread articles marked as read, you can use `gnus-summary-mark-unread-as-read` instead. It will leave marks like `gnus-low-score-mark`, `gnus-del-mark` (and so on) alone.

## Scrolling the Article

`SPACE`
  Pressing `SPACE` will scroll the current article forward one page, or, if you have come to the end of the current article, will choose the next article (`gnus-summary-next-page`).
`DEL`
  Scroll the current article back one page (`gnus-summary-prev-page`).
`RET`
  Scroll the current article one line forward (`gnus-summary-scroll-up`).
`A g`
`g`
  (Re)fetch the current article (`gnus-summary-show-article`). If given a prefix, fetch the current article, but don't run any of the article treatment functions. This will give you a "raw" article, just the way it came from the server.
`A <`
`<`
  Scroll to the beginning of the article (`gnus-summary-beginning-of-article`).
`A >`
`>`
  Scroll to the end of the article (`gnus-summary-end-of-article`).
`A s`
  Perform an isearch in the article buffer (`gnus-summary-isearch-article`).

## Reply, Followup and Post

- Summary Mail Commands: Sending mail.
- Summary Post Commands: Sending news.

### Summary Mail Commands

Commands for composing a mail message:

`S r`
`r`
  Mail a reply to the author of the current article (`gnus-summary-reply`).
`S R`
`R`
  Mail a reply to the author of the current article and include the original message (`gnus-summary-reply-with-original`). This command uses the process/prefix convention.
`S o m`
  Forward the current article to some other person (`gnus-summary-mail-forward`).
`S o p`
  Forward the current article to a newsgroup (`gnus-summary-post-forward`).
`S m`
`m`
  Send a mail to some other person (`gnus-summary-mail-other-window`).
`S D b`
  If you have sent a mail, but the mail was bounced back to you for some reason (wrong address, transient failure), you can use this command to resend that bounced mail (`gnus-summary-resend-bounced-mail`). You will be popped into a mail buffer where you can edit the headers before sending the mail off again. If you give a prefix to this command, and the bounced mail is a reply to some other mail, Gnus will try to fetch that mail and display it for easy perusal of its headers. This might very well fail, though.
`S D r`
  Not to be confused with the previous command, `gnus-summary-resend-message` will prompt you for an address to send the current message off to, and then send it to that place. The headers of the message won't be altered--but lots of headers that say `Resent-To`, `Resent-From` and so on will be added. This means that you actually send a mail to someone that has a `To` header that (probably) points to yourself. This will confuse people. So, natcherly you'll only do that if you're really eVIl. This command is mainly used if you have several accounts and want to ship a mail to a different account of yours. (If you're both `root` and `postmaster` and get a mail for `postmaster` to the `root` account, you may want to resend it to `postmaster`. Ordnung muss sein!
`S O m`
  Digest the current series and forward the result using mail (`gnus-uu-digest-mail-forward`). This command uses the process/prefix convention (see section Process/Prefix).
`S O p`
  Digest the current series and forward the result to a newsgroup (`gnus-uu-digest-mail-forward`).

### Summary Post Commands

Commands for posting an article:

`S p`
`a`
  Post an article to the current group (`gnus-summary-post-news`).
`S f`
`f`
  Post a followup to the current article (`gnus-summary-followup`).
`S F`
`F`
  Post a followup to the current article and include the original message (`gnus-summary-followup-with-original`). This command uses the process/prefix convention.
`S u`
  Uuencode a file, split it into parts, and post it as a series (`gnus-uu-post-news`). (see section Uuencoding and Posting).

## Canceling Articles

Have you ever written something, and then decided that you really, really, really wish you hadn't posted that?

Well, you can't cancel mail, but you can cancel posts.

Find the article you wish to cancel (you can only cancel your own articles, so don't try any funny stuff). Then press `C` or `S c` (`gnus-summary-cancel-article`). Your article will be canceled--machines all over the world will be deleting your article.

Be aware, however, that not all sites honor cancels, so your article may live on here and there, while most sites will delete the article in question.

If you discover that you have made some mistakes and want to do some corrections, you can post a superseding article that will replace your original article.

Go to the original article and press `S s` (`gnus-summary-supersede-article`). You will be put in a buffer where you can edit the article all you want before sending it off the usual way.

The same goes for superseding as for canceling, only more so: Some sites do not honor superseding. On those sites, it will appear that you have posted almost the same article twice.

If you have just posted the article, and change your mind right away, there is a trick you can use to cancel/supersede the article without waiting for the article to appear on your site first. You simply return to the post buffer (which is called `*post-buf*`). There you will find the article you just posted, with all the headers intact. Change the `Message-ID` header to a `Cancel` or `Supersedes` header by substituting one of those words for `Message-ID`. Then just press `C-c C-c` to send the article as you would do normally. The previous article will be canceled/superseded.

Just remember, kids: There is no 'c' in 'supersede'.

## Marking Articles

There are several marks you can set on an article.

You have marks that decide the readedness (whoo, neato-keano neologism ohoy!) of the article. Alphabetic marks generally mean read, while non-alphabetic characters generally mean unread.

In addition, you also have marks that do not affect readedness.

- Unread Articles: Marks for unread articles.
- Read Articles: Marks for read articles.
- Other Marks: Marks that do not affect readedness.

- Setting Marks: How to set and remove marks.
- Setting Process Marks: How to mark articles for later processing.

### Unread Articles

The following marks mark articles as unread, in one form or other.

``!'`
  Ticked articles are articles that will remain visible always. If you see an article that you find interesting, or you want to put off reading it, or replying to it, until sometime later, you'd typically tick it. However, articles can be expired, so if you want to keep an article forever, you'll have to save it. Ticked articles have a ``!'` (`gnus-ticked-mark`) in the first column.
``?'`
  A dormant article is marked with a ``?'` (`gnus-dormant-mark`), and will only appear in the summary buffer if there are followups to it.
``SPACE'`
  An unread article is marked with a ``SPACE'` (`gnus-unread-mark`). These are articles that haven't been read at all yet.

### Read Articles

All the following marks mark articles as read.

``r'`
  Articles that are marked as read. They have a ``r'` (`gnus-del-mark`) in the first column. These are articles that the user has marked as read more or less manually.
``R'`
  Articles that are actually read are marked with ``R'` (`gnus-read-mark`).
``O'`
  Articles that were marked as read in previous sessions are now old and marked with ``O'` (`gnus-ancient-mark`).
``K'`
  Marked as killed (`gnus-killed-mark`).
``X'`
  Marked as killed by kill files (`gnus-kill-file-mark`).
``Y'`
  Marked as read by having a too low score (`gnus-low-score-mark`).
``C'`
  Marked as read by a catchup (`gnus-catchup-mark`).
``G'`
  Canceled article (`gnus-canceled-mark`)
``F'`
  SOUPed article (`gnus-souped-mark`).
``Q'`
  Sparsely reffed article (`gnus-sparse-mark`).

All these marks just mean that the article is marked as read, really. They are interpreted differently by the adaptive scoring scheme, however.

One more special mark, though:

``E'`
  You can also mark articles as expirable (or have them marked as such automatically). That doesn't make much sense in normal groups, because a user does not control the expiring of news articles, but in mail groups, for instance, articles that are marked as expirable can be deleted by Gnus at any time. Expirable articles are marked with ``E'` (`gnus-expirable-mark`).

### Other Marks

There are some marks that have nothing to do with whether the article is read or not.

- You can set a bookmark in the current article. Say you are reading a long thesis on cats' urinary tracts, and have to go home for dinner before you've finished reading the thesis. You can then set a bookmark in the article, and Gnus will jump to this bookmark the next time it encounters the article.
- All articles that you have replied to or made a followup to (i.e., have answered) will be marked with an ``A'` in the second column (`gnus-replied-mark`).
- Articles that are stored in the article cache will be marked with an ``*'` in the second column (`gnus-cached-mark`).
- Articles that are "saved" (in some manner or other; not necessarily religiously) are marked with an ``S'` in the second column (`gnus-saved-mark`.
- It the ``%e'` spec is used, the presence of threads or not will be marked with `gnus-not-empty-thread-mark` and `gnus-empty-thread-mark` in the third column, respectively.
- Finally we have the process mark (`gnus-process-mark`. A variety of commands react to the presence of the process mark. For instance, `X u` (`gnus-uu-decode-uu`) will uudecode and view all articles that have been marked with the process mark. Articles marked with the process mark have a ``#'` in the second column.

You might have noticed that most of these "non-readedness" marks appear in the second column by default. So if you have a cached, saved, replied article that you have process-marked, what will that look like?

Nothing much. The precedence rules go as follows: process -> cache -> replied -> saved. So if the article is in the cache and is replied, you'll only see the cache mark and not the replied mark.

### Setting Marks

All the marking commands understand the numeric prefix.

`M t`
`!`
  Tick the current article (`gnus-summary-tick-article-forward`).
`M ?`
`?`
  Mark the current article as dormant (`gnus-summary-mark-as-dormant`).
`M d`
`d`
  Mark the current article as read (`gnus-summary-mark-as-read-forward`).
`M k`
`k`
  Mark all articles that have the same subject as the current one as read, and then select the next unread article (`gnus-summary-kill-same-subject-and-select`).
`M K`
`C-k`
  Mark all articles that have the same subject as the current one as read (`gnus-summary-kill-same-subject`).
`M C`
  Mark all unread articles in the group as read (`gnus-summary-catchup`).
`M C-c`
  Mark all articles in the group as read--even the ticked and dormant articles (`gnus-summary-catchup-all`).
`M H`
  Catchup the current group to point (`gnus-summary-catchup-to-here`).
`C-w`
  Mark all articles between point and mark as read (`gnus-summary-mark-region-as-read`).
`M V k`
  Kill all articles with scores below the default score (or below the numeric prefix) (`gnus-summary-kill-below`).
`M c`
`M-u`
  Clear all readedness-marks from the current article (`gnus-summary-clear-mark-forward`).
`M e`
`E`
  Mark the current article as expirable (`gnus-summary-mark-as-expirable`).
`M b`
  Set a bookmark in the current article (`gnus-summary-set-bookmark`).
`M B`
  Remove the bookmark from the current article (`gnus-summary-remove-bookmark`).
`M V c`
  Clear all marks from articles with scores over the default score (or over the numeric prefix) (`gnus-summary-clear-above`).
`M V u`
  Tick all articles with scores over the default score (or over the numeric prefix) (`gnus-summary-tick-above`).
`M V m`
  Prompt for a mark, and mark all articles with scores over the default score (or over the numeric prefix) with this mark (`gnus-summary-clear-above`).

The `gnus-summary-goto-unread` variable controls what action should be taken after setting a mark. If non-`nil`, point will move to the next/previous unread article. If `nil`, point will just move one line up or down. As a special case, if this variable is `never`, all the marking commands as well as other commands (like `SPACE`) will move to the next article, whether it is unread or not. The default is `t`.

### Setting Process Marks

`M P p`
`#`
  Mark the current article with the process mark (`gnus-summary-mark-as-processable`).
`M P u`
`M-#`
  Remove the process mark, if any, from the current article (`gnus-summary-unmark-as-processable`).
`M P U`
  Remove the process mark from all articles (`gnus-summary-unmark-all-processable`).
`M P R`
  Mark articles by a regular expression (`gnus-uu-mark-by-regexp`).
`M P r`
  Mark articles in region (`gnus-uu-mark-region`).
`M P t`
  Mark all articles in the current (sub)thread (`gnus-uu-mark-thread`).
`M P T`
  Unmark all articles in the current (sub)thread (`gnus-uu-unmark-thread`).
`M P v`
  Mark all articles that have a score above the prefix argument (`gnus-uu-mark-over`).
`M P s`
  Mark all articles in the current series (`gnus-uu-mark-series`).
`M P S`
  Mark all series that have already had some articles marked (`gnus-uu-mark-sparse`).
`M P a`
  Mark all articles in series order (`gnus-uu-mark-series`).
`M P b`
  Mark all articles in the buffer in the order they appear (`gnus-uu-mark-buffer`).

## Limiting

It can be convenient to limit the summary buffer to just show some subset of the articles currently in the group. The effect most limit commands have is to remove a few (or many) articles from the summary buffer.

`/ /`
`/ s`
  Limit the summary buffer to articles that match some subject (`gnus-summary-limit-to-subject`).
`/ a`
  Limit the summary buffer to articles that match some author (`gnus-summary-limit-to-author`).
`/ u`
`x`
  Limit the summary buffer to articles that are not marked as read (`gnus-summary-limit-to-unread`). If given a prefix, limit the buffer to articles that are strictly unread. This means that ticked and dormant articles will also be excluded.
`/ m`
  Ask for a mark and then limit to all articles that have not been marked with that mark (`gnus-summary-limit-to-marks`).
`/ n`
  Limit the summary buffer to the current article (`gnus-summary-limit-to-articles`). Uses the process/prefix convention (see section Process/Prefix).
`/ w`
  Pop the previous limit off the stack and restore it (`gnus-summary-pop-limit`). If given a prefix, pop all limits off the stack.
`/ v`
  Limit the summary buffer to articles that have a score at or above some score (`gnus-summary-limit-to-score`).
`/ E`
`M S`
  Display all expunged articles (`gnus-summary-limit-include-expunged`).
`/ D`
  Display all dormant articles (`gnus-summary-limit-include-dormant`).
`/ d`
  Hide all dormant articles (`gnus-summary-limit-exclude-dormant`).
`/ c`
  Hide all dormant articles that have no children (`gnus-summary-limit-exclude-childless-dormant`).
`/ C`
  Mark all excluded unread articles as read (`gnus-summary-limit-mark-excluded-as-read`). If given a prefix, also mark excluded ticked and dormant articles as read.

## Threading

Gnus threads articles by default. To thread is to put replies to articles directly after the articles they reply to--in a hierarchical fashion.

- Customizing Threading: Variables you can change to affect the threading.
- Thread Commands: Thread based commands in the summary buffer.

### Customizing Threading

`gnus-show-threads`
  If this variable is `nil`, no threading will be done, and all of the rest of the variables here will have no effect. Turning threading off will speed group selection up a bit, but it is sure to make reading slower and more awkward.
`gnus-fetch-old-headers`
  If non-`nil`, Gnus will attempt to build old threads by fetching more old headers--headers to articles that are marked as read. If you would like to display as few summary lines as possible, but still connect as many loose threads as possible, you should set this variable to `some` or a number. If you set it to a number, no more than that number of extra old headers will be fetched. In either case, fetching old headers only works if the backend you are using carries overview files--this would normally be `nntp`, `nnspool` and `nnml`. Also remember that if the root of the thread has been expired by the server, there's not much Gnus can do about that.
`gnus-build-sparse-threads`
  Fetching old headers can be slow. A low-rent similar effect can be gotten by setting this variable to `some`. Gnus will then look at the complete `References` headers of all articles and try to string articles that belong in the same thread together. This will leave gaps in the threading display where Gnus guesses that an article is missing from the thread. (These gaps appear like normal summary lines. If you select a gap, Gnus will try to fetch the article in question.) If this variable is `t`, Gnus will display all these "gaps" without regard for whether they are useful for completing the thread or not. Finally, if this variable is `more`, Gnus won't cut off sparse leaf nodes that don't lead anywhere. This variable is `nil` by default.
`gnus-summary-gather-subject-limit`
  Loose threads are gathered by comparing subjects of articles. If this variable is `nil`, Gnus requires an exact match between the subjects of the loose threads before gathering them into one big super-thread. This might be too strict a requirement, what with the presence of stupid newsreaders that chop off long subjects lines. If you think so, set this variable to, say, 20 to require that only the first 20 characters of the subjects have to match. If you set this variable to a really low number, you'll find that Gnus will gather everything in sight into one thread, which isn't very helpful. If you set this variable to the special value `fuzzy`, Gnus will use a fuzzy string comparison algorithm on the subjects.
`gnus-simplify-subject-fuzzy-regexp`
  This can either be a regular expression or list of regular expressions that match strings that will be removed from subjects if fuzzy subject simplification is used.
`gnus-simplify-ignored-prefixes`
  If you set `gnus-summary-gather-subject-limit` to something as low as 10, you might consider setting this variable to something sensible:

      (setq gnus-simplify-ignored-prefixes
            (concat
             "\\`\\[?\\("
             (mapconcat 'identity
                        '("looking"
                           "wanted" "followup" "summary\\( of\\)?"
                           "help" "query" "problem" "question"
                           "answer" "reference" "announce"
                           "How can I" "How to" "Comparison of"
                           ;; ...
                           )
                        "\\|")
                        "\\)\\s *\\("
                        (mapconcat 'identity
                                   '("for" "for reference" "with" "about")
                                   "\\|")
                        "\\)?\\]?:?[ \t]*"))

  All words that match this regexp will be removed before comparing two subjects.
`gnus-summary-gather-exclude-subject`
  Since loose thread gathering is done on subjects only, that might lead to many false hits, especially with certain common subjects like ``'` and ``(none)'`. To make the situation slightly better, you can use the regexp `gnus-summary-gather-exclude-subject` to say what subjects should be excluded from the gathering process. The default is ``^ *$\\|^(none)$'`.
`gnus-summary-thread-gathering-function`
  Gnus gathers threads by looking at `Subject` headers. This means that totally unrelated articles may end up in the same "thread", which is confusing. An alternate approach is to look at all the `Message-ID`s in all the `References` headers to find matches. This will ensure that no gathered threads ever includes unrelated articles, but it's also means that people who have posted with broken newsreaders won't be gathered properly. The choice is yours--plague or cholera:
  `gnus-gather-threads-by-subject`
    This function is the default gathering function and looks at `Subject`s exclusively.
  `gnus-gather-threads-by-references`
    This function looks at `References` headers exclusively.
  If you want to test gathering by `References`, you could say something like:

      (setq gnus-summary-thread-gathering-function
            'gnus-gather-threads-by-references)

`gnus-summary-make-false-root`
  If non-`nil`, Gnus will gather all loose subtrees into one big tree and create a dummy root at the top. (Wait a minute. Root at the top? Yup.) Loose subtrees occur when the real root has expired, or you've read or killed the root in a previous session. When there is no real root of a thread, Gnus will have to fudge something. This variable says what fudging method Gnus should use. There are four possible values:
  `adopt`
    Gnus will make the first of the orphaned articles the parent. This parent will adopt all the other articles. The adopted articles will be marked as such by pointy brackets (``<>'`) instead of the standard square brackets (``[]'`). This is the default method.
  `dummy`
    Gnus will create a dummy summary line that will pretend to be the parent. This dummy line does not correspond to any real article, so selecting it will just select the first real article after the dummy article. `gnus-summary-dummy-line-format` is used to specify the format of the dummy roots. It accepts only one format spec: ``S'`, which is the subject of the article. See section Formatting Variables.
  `empty`
    Gnus won't actually make any article the parent, but simply leave the subject field of all orphans except the first empty. (Actually, it will use `gnus-summary-same-subject` as the subject (see section Summary Buffer Format).)
  `none`
    Don't make any article parent at all. Just gather the threads and display them after one another.
  `nil`
    Don't gather loose threads.
`gnus-thread-hide-subtree`
  If non-`nil`, all threads will be hidden when the summary buffer is generated.
`gnus-thread-hide-killed`
  if you kill a thread and this variable is non-`nil`, the subtree will be hidden.
`gnus-thread-ignore-subject`
  Sometimes somebody changes the subject in the middle of a thread. If this variable is non-`nil`, the subject change is ignored. If it is `nil`, which is the default, a change in the subject will result in a new thread.
`gnus-thread-indent-level`
  This is a number that says how much each sub-thread should be indented. The default is `4`.

### Thread Commands

`T k`
`M-C-k`
  Mark all articles in the current sub-thread as read (`gnus-summary-kill-thread`). If the prefix argument is positive, remove all marks instead. If the prefix argument is negative, tick articles instead.
`T l`
`M-C-l`
  Lower the score of the current thread (`gnus-summary-lower-thread`).
`T i`
  Increase the score of the current thread (`gnus-summary-raise-thread`).
`T #`
  Set the process mark on the current thread (`gnus-uu-mark-thread`).
`T M-#`
  Remove the process mark from the current thread (`gnus-uu-unmark-thread`).
`T T`
  Toggle threading (`gnus-summary-toggle-threads`).
`T s`
  Expose the thread hidden under the current article, if any (`gnus-summary-show-thread`).
`T h`
  Hide the current (sub)thread (`gnus-summary-hide-thread`).
`T S`
  Expose all hidden threads (`gnus-summary-show-all-threads`).
`T H`
  Hide all threads (`gnus-summary-hide-all-threads`).
`T t`
  Re-thread the thread the current article is part of (`gnus-summary-rethread-current`). This works even when the summary buffer is otherwise unthreaded.
`T ^`
  Make the current article the child of the marked (or previous) article (`gnus-summary-reparent-thread`.

The following commands are thread movement commands. They all understand the numeric prefix.

`T n`
  Go to the next thread (`gnus-summary-next-thread`).
`T p`
  Go to the previous thread (`gnus-summary-prev-thread`).
`T d`
  Descend the thread (`gnus-summary-down-thread`).
`T u`
  Ascend the thread (`gnus-summary-up-thread`).
`T o`
  Go to the top of the thread (`gnus-summary-top-thread`).

If you ignore subject while threading, you'll naturally end up with threads that have several different subjects in them. If you then issue a command like `T k' (`gnus-summary-kill-thread`) you might not wish to kill the entire thread, but just those parts of the thread that have the same subject as the current article. If you like this idea, you can fiddle with `gnus-thread-operation-ignore-subject`. If is is non-`nil` (which it is by default), subjects will be ignored when doing thread commands. If this variable is `nil`, articles in the same thread with different subjects will not be included in the operation in question. If this variable is `fuzzy`, only articles that have subjects that are fuzzily equal will be included.

## Sorting

If you are using a threaded summary display, you can sort the threads by setting `gnus-thread-sort-functions`, which is a list of functions. By default, sorting is done on article numbers. Ready-made sorting predicate functions include `gnus-thread-sort-by-number`, `gnus-thread-sort-by-author`, `gnus-thread-sort-by-subject`, `gnus-thread-sort-by-date`, `gnus-thread-sort-by-score`, and `gnus-thread-sort-by-total-score`.

Each function takes two threads and return non-`nil` if the first thread should be sorted before the other. Note that sorting really is normally done by looking only at the roots of each thread. If you use more than one function, the primary sort key should be the last function in the list. You should probably always include `gnus-thread-sort-by-number` in the list of sorting functions--preferably first. This will ensure that threads that are equal with respect to the other sort criteria will be displayed in ascending article order.

If you would like to sort by score, then by subject, and finally by number, you could do something like:

    (setq gnus-thread-sort-functions
          '(gnus-thread-sort-by-number
            gnus-thread-sort-by-subject
            gnus-thread-sort-by-score))

The threads that have highest score will be displayed first in the summary buffer. When threads have the same score, they will be sorted alphabetically. The threads that have the same score and the same subject will be sorted by number, which is (normally) the sequence in which the articles arrived.

If you want to sort by score and then reverse arrival order, you could say something like:

    (setq gnus-thread-sort-functions
          '((lambda (t1 t2)
              (not (gnus-thread-sort-by-number t1 t2)))
            gnus-thread-sort-by-score))

The function in the `gnus-thread-score-function` variable (default `+`) is used for calculating the total score of a thread. Useful functions might be `max`, `min`, or squared means, or whatever tickles your fancy.

If you are using an unthreaded display for some strange reason or other, you have to fiddle with the `gnus-article-sort-functions` variable. It is very similar to the `gnus-thread-sort-functions`, except that is uses slightly different functions for article comparison. Available sorting predicate functions are `gnus-article-sort-by-number`, `gnus-article-sort-by-author`, `gnus-article-sort-by-subject`, `gnus-article-sort-by-date`, and `gnus-article-sort-by-score`.

If you want to sort an unthreaded summary display by subject, you could say something like:

    (setq gnus-article-sort-functions
          '(gnus-article-sort-by-number
            gnus-article-sort-by-subject))

## Asynchronous Article Fetching

If you read your news from an NNTP server that's far away, the network latencies may make reading articles a chore. You have to wait for a while after pressing `n` to go to the next article before the article appears. Why can't Gnus just go ahead and fetch the article while you are reading the previous one? Why not, indeed.

First, some caveats. There are some pitfalls to using asynchronous article fetching, especially the way Gnus does it.

Let's say you are reading article 1, which is short, and article 2 is quite long, and you are not interested in reading that. Gnus does not know this, so it goes ahead and fetches article 2. You decide to read article 3, but since Gnus is in the process of fetching article 2, the connection is blocked.

To avoid these situations, Gnus will open two (count 'em two) connections to the server. Some people may think this isn't a very nice thing to do, but I don't see any real alternatives. Setting up that extra connection takes some time, so Gnus startup will be slower.

Gnus will fetch more articles than you will read. This will mean that the link between your machine and the NNTP server will become more loaded than if you didn't use article pre-fetch. The server itself will also become more loaded--both with the extra article requests, and the extra connection.

Ok, so now you know that you shouldn't really use this thing... unless you really want to.

Here's how: Set `gnus-asynchronous` to `t`. The rest should happen automatically.

You can control how many articles that are to be pre-fetched by setting `nntp-async-number`. This is five by default, which means that when you read an article in the group, `nntp` will pre-fetch the next five articles. If this variable is `t`, `nntp` will pre-fetch all the articles that it can without bound. If it is `nil`, no pre-fetching will be made.

You may wish to create some sort of scheme for choosing which articles that `nntp` should consider as candidates for pre-fetching. For instance, you may wish to pre-fetch all articles with high scores, and not pre-fetch low-scored articles. You can do that by setting the `gnus-asynchronous-article-function`, which will be called with an alist where the keys are the article numbers. Your function should return an alist where the articles you are not interested in have been removed. You could also do sorting on article score and the like.

## Article Caching

If you have an extremely slow NNTP connection, you may consider turning article caching on. Each article will then be stored locally under your home directory. As you may surmise, this could potentially use huge amounts of disk space, as well as eat up all your inodes so fast it will make your head swim. In vodka.

Used carefully, though, it could be just an easier way to save articles.

To turn caching on, set `gnus-use-cache` to `t`. By default, all articles that are ticked or marked as dormant will then be copied over to your local cache (`gnus-cache-directory`). Whether this cache is flat or hierarchal is controlled by the `gnus-use-long-file-name` variable, as usual.

When re-select a ticked or dormant article, it will be fetched from the cache instead of from the server. As articles in your cache will never expire, this might serve as a method of saving articles while still keeping them where they belong. Just mark all articles you want to save as dormant, and don't worry.

When an article is marked as read, is it removed from the cache.

The entering/removal of articles from the cache is controlled by the `gnus-cache-enter-articles` and `gnus-cache-remove-articles` variables. Both are lists of symbols. The first is `(ticked dormant)` by default, meaning that ticked and dormant articles will be put in the cache. The latter is `(read)` by default, meaning that articles that are marked as read are removed from the cache. Possibly symbols in these two lists are `ticked`, `dormant`, `unread` and `read`.

So where does the massive article-fetching and storing come into the picture? The `gnus-jog-cache` command will go through all subscribed newsgroups, request all unread articles, and store them in the cache. You should only ever, ever ever ever, use this command if 1) your connection to the NNTP server is really, really, really slow and 2) you have a really, really, really huge disk. Seriously.

It is likely that you do not want caching on some groups. For instance, if your `nnml` mail is located under your home directory, it makes no sense to cache it somewhere else under your home directory. Unless you feel that it's neat to use twice as much space. To limit the caching, you could set the `gnus-uncacheable-groups` regexp to ``^nnml'`, for instance. This variable is `nil` by default.

The cache stores information on what articles it contains in its active file (`gnus-cache-active-file`). If this file (or any other parts of the cache) becomes all messed up for some reason or other, Gnus offers two functions that will try to set things right. `M-x gnus-cache-generate-nov-databases` will (re)build all the NOV files, and `gnus-cache-generate-active` will (re)generate the active file.

## Persistent Articles

Closely related to article caching, we have persistent articles. In fact, it's just a different way of looking at caching, and much more useful in my opinion.

Say you're reading a newsgroup, and you happen on to some valuable gem that you want to keep and treasure forever. You'd normally just save it (using one of the many saving commands) in some file. The problem with that is that it's just, well, yucky. Ideally you'd prefer just having the article remain in the group where you found it forever; untouched by the expiry going on at the news server.

This is what a persistent article is--an article that just won't be deleted. It's implemented using the normal cache functions, but you use two explicit commands for managing persistent articles:

`*`
  Make the current article persistent (`gnus-cache-enter-article`).
`M-*`
  Remove the current article from the persistent articles (`gnus-cache-remove-article`). This will normally delete the article.

Both these commands understand the process/prefix convention.

To avoid having all ticked articles (and stuff) entered into the cache, you should set `gnus-use-cache` to `passive` if you're just interested in persistent articles:

    (setq gnus-use-cache 'passive)

## Article Backlog

If you have a slow connection, but the idea of using caching seems unappealing to you (and it is, really), you can help the situation some by switching on the backlog. This is where Gnus will buffer already read articles so that it doesn't have to re-fetch articles you've already read. This only helps if you are in the habit of re-selecting articles you've recently read, of course. If you never do that, turning the backlog on will slow Gnus down a little bit, and increase memory usage some.

If you set `gnus-keep-backlog` to a number n, Gnus will store at most n old articles in a buffer for later re-fetching. If this variable is non-`nil` and is not a number, Gnus will store all read articles, which means that your Emacs will grow without bound before exploding and taking your machine down with you. I put that in there just to keep y'all on your toes.

This variable is `nil` by default.

## Saving Articles

Gnus can save articles in a number of ways. Below is the documentation for saving articles in a fairly straight-forward fashion (i.e., little processing of the article is done before it is saved). For a different approach (uudecoding, unsharing) you should use `gnus-uu` (see section Decoding Articles).

If `gnus-save-all-headers` is non-`nil`, Gnus will not delete unwanted headers before saving the article.

If the preceding variable is `nil`, all headers that match the `gnus-saved-headers` regexp will be kept, while the rest will be deleted before saving.

`O o`
`o`
  Save the current article using the default article saver (`gnus-summary-save-article`).
`O m`
  Save the current article in mail format (`gnus-summary-save-article-mail`).
`O r`
  Save the current article in rmail format (`gnus-summary-save-article-rmail`).
`O f`
  Save the current article in plain file format (`gnus-summary-save-article-file`).
`O b`
  Save the current article body in plain file format (`gnus-summary-save-article-body-file`).
`O h`
  Save the current article in mh folder format (`gnus-summary-save-article-folder`).
`O v`
  Save the current article in a VM folder (`gnus-summary-save-article-vm`).
`O p`
  Save the current article in a pipe. Uhm, like, what I mean is--Pipe the current article to a process (`gnus-summary-pipe-output`).

All these commands use the process/prefix convention (see section Process/Prefix). If you save bunches of articles using these functions, you might get tired of being prompted for files to save each and every article in. The prompting action is controlled by the `gnus-prompt-before-saving` variable, which is `always` by default, giving you that excessive prompting action you know and loathe. If you set this variable to `t` instead, you'll be prompted just once for each series of articles you save. If you like to really have Gnus do all your thinking for you, you can even set this variable to `nil`, which means that you will never be prompted for files to save articles in. Gnus will simply save all the articles in the default files.

You can customize the `gnus-default-article-saver` variable to make Gnus do what you want it to. You can use any of the four ready-made functions below, or you can create your own.

`gnus-summary-save-in-rmail`
  This is the default format, babyl. Uses the function in the `gnus-rmail-save-name` variable to get a file name to save the article in. The default is `gnus-plain-save-name`.
`gnus-summary-save-in-mail`
  Save in a Unix mail (mbox) file. Uses the function in the `gnus-mail-save-name` variable to get a file name to save the article in. The default is `gnus-plain-save-name`.
`gnus-summary-save-in-file`
  Append the article straight to an ordinary file. Uses the function in the `gnus-file-save-name` variable to get a file name to save the article in. The default is `gnus-numeric-save-name`.
`gnus-summary-save-body-in-file`
  Append the article body to an ordinary file. Uses the function in the `gnus-file-save-name` variable to get a file name to save the article in. The default is `gnus-numeric-save-name`.
`gnus-summary-save-in-folder`
  Save the article to an MH folder using `rcvstore` from the MH library. Uses the function in the `gnus-folder-save-name` variable to get a file name to save the article in. The default is `gnus-folder-save-name`, but you can also use `gnus-Folder-save-name`. The former creates capitalized names, and the latter does not.
`gnus-summary-save-in-vm`
  Save the article in a VM folder. You have to have the VM mail reader to use this setting.

All of these functions, except for the last one, will save the article in the `gnus-article-save-directory`, which is initialized from the `SAVEDIR` environment variable. This is ``~/News/'` by default.

As you can see above, the functions use different functions to find a suitable name of a file to save the article in. Below is a list of available functions that generate names:

`gnus-Numeric-save-name`
  Generates file names that look like ``~/News/Alt.andrea-dworkin/45'`.
`gnus-numeric-save-name`
  Generates file names that look like ``~/News/alt.andrea-dworkin/45'`.
`gnus-Plain-save-name`
  Generates file names that look like ``~/News/Alt.andrea-dworkin'`.
`gnus-plain-save-name`
  Generates file names that look like ``~/News/alt.andrea-dworkin'`.

You can have Gnus suggest where to save articles by plonking a regexp into the `gnus-split-methods` alist. For instance, if you would like to save articles related to Gnus in the file ``gnus-stuff'`, and articles related to VM in `vm-stuff`, you could set this variable to something like:

    (("^Subject:.*gnus\\|^Newsgroups:.*gnus" "gnus-stuff")
     ("^Subject:.*vm\\|^Xref:.*vm" "vm-stuff")
     (my-choosing-function "../other-dir/my-stuff")
     ((equal gnus-newsgroup-name "mail.misc") "mail-stuff"))

We see that this is a list where each element is a list that has two elements--the match and the file. The match can either be a string (in which case it is used as a regexp to match on the article head); it can be a symbol (which will be called as a function with the group name as a parameter); or it can be a list (which will be `eval`ed). If any of these actions have a non-`nil` result, the file will be used as a default prompt. In addition, the result of the operation itself will be used if the function or form called returns a string or a list of strings.

You basically end up with a list of file names that might be used when saving the current article. (All "matches" will be used.) You will then be prompted for what you really want to use as a name, with file name completion over the results from applying this variable.

This variable is `((gnus-article-archive-name))` by default, which means that Gnus will look at the articles it saves for an `Archive-name` line and use that as a suggestion for the file name.

Finally, you have the `gnus-use-long-file-name` variable. If it is `nil`, all the preceding functions will replace all periods (``.'`) in the group names with slashes (``/'`)---which means that the functions will generate hierarchies of directories instead of having all the files in the toplevel directory (``~/News/alt/andrea-dworkin'` instead of ``~/News/alt.andrea-dworkin'`.) This variable is `t` by default on most systems. However, for historical reasons, this is `nil` on Xenix and usg-unix-v machines by default.

This function also affects kill and score file names. If this variable is a list, and the list contains the element `not-score`, long file names will not be used for score files, if it contains the element `not-save`, long file names will not be used for saving, and if it contains the element `not-kill`, long file names will not be used for kill files.

If you'd like to save articles in a hierarchy that looks something like a spool, you could

    (setq gnus-use-long-file-name '(not-save)) ; to get a hierarchy
    (setq gnus-default-article-save 'gnus-summary-save-in-file) ; no encoding

Then just save with `o`. You'd then read this hierarchy with ephemeral `nneething` groups---`G D` in the group buffer, and the toplevel directory as the argument (``~/News/'`). Then just walk around to the groups/directories with `nneething`.

## Decoding Articles

Sometime users post articles (or series of articles) that have been encoded in some way or other. Gnus can decode them for you.

- Uuencoded Articles: Uudecode articles.
- Shared Articles: Unshar articles.
- PostScript Files: Split PostScript.
- Decoding Variables: Variables for a happy decoding.
- Viewing Files: You want to look at the result of the decoding?

All these functions use the process/prefix convention (see section Process/Prefix) for finding out what articles to work on, with the extension that a "single article" means "a single series". Gnus can find out by itself what articles belong to a series, decode all the articles and unpack/view/save the resulting file(s).

Gnus guesses what articles are in the series according to the following simplish rule: The subjects must be (nearly) identical, except for the last two numbers of the line. (Spaces are largely ignored, however.)

For example: If you choose a subject called ``cat.gif (2/3)'`, Gnus will find all the articles that match the regexp ``^cat.gif ([0-9]+/[0-9]+).*$'`.

Subjects that are nonstandard, like ``cat.gif (2/3) Part 6 of a series'`, will not be properly recognized by any of the automatic viewing commands, and you have to mark the articles manually with `#`.

### Uuencoded Articles

`X u`
  Uudecodes the current series (`gnus-uu-decode-uu`).
`X U`
  Uudecodes and saves the current series (`gnus-uu-decode-uu-and-save`).
`X v u`
  Uudecodes and views the current series (`gnus-uu-decode-uu-view`).
`X v U`
  Uudecodes, views and saves the current series (`gnus-uu-decode-uu-and-save-view`).

Remember that these all react to the presence of articles marked with the process mark. If, for instance, you'd like to decode and save an entire newsgroup, you'd typically do `M P a` (`gnus-uu-mark-all`) and then `X U` (`gnus-uu-decode-uu-and-save`).

All this is very much different from how `gnus-uu` worked with GNUS 4.1, where you had explicit keystrokes for everything under the sun. This version of `gnus-uu` generally assumes that you mark articles in some way (see section Setting Process Marks) and then press `X u`.

Note: When trying to decode articles that have names matching `gnus-uu-notify-files`, which is hard-coded to ``[Cc][Ii][Nn][Dd][Yy][0-9]+.\\(gif\\|jpg\\)'`, `gnus-uu` will automatically post an article on ``comp.unix.wizards'` saying that you have just viewed the file in question. This feature can't be turned off.

### Shared Articles

`X s`
  Unshars the current series (`gnus-uu-decode-unshar`).
`X S`
  Unshars and saves the current series (`gnus-uu-decode-unshar-and-save`).
`X v s`
  Unshars and views the current series (`gnus-uu-decode-unshar-view`).
`X v S`
  Unshars, views and saves the current series (`gnus-uu-decode-unshar-and-save-view`).

### PostScript Files

`X p`
  Unpack the current PostScript series (`gnus-uu-decode-postscript`).
`X P`
  Unpack and save the current PostScript series (`gnus-uu-decode-postscript-and-save`).
`X v p`
  View the current PostScript series (`gnus-uu-decode-postscript-view`).
`X v P`
  View and save the current PostScript series (`gnus-uu-decode-postscript-and-save-view`).

### Decoding Variables

Adjective, not verb.

- Rule Variables: Variables that say how a file is to be viewed.
- Other Decode Variables: Other decode variables.
- Uuencoding and Posting: Variables for customizing uuencoding.

#### Rule Variables

Gnus uses rule variables to decide how to view a file. All these variables are on the form

          (list '(regexp1 command2)
                '(regexp2 command2)
                ...)

`gnus-uu-user-view-rules`
  This variable is consulted first when viewing files. If you wish to use, for instance, `sox` to convert an ``.au'` sound file, you could say something like:

             (setq gnus-uu-user-view-rules
               (list '(\"\\\\.au$\" \"sox %s -t .aiff > /dev/audio\")))

`gnus-uu-user-view-rules-end`
  This variable is consulted if Gnus couldn't make any matches from the user and default view rules.
`gnus-uu-user-archive-rules`
  This variable can be used to say what commands should be used to unpack archives.

#### Other Decode Variables

`gnus-uu-grabbed-file-functions`
  All functions in this list will be called right each file has been successfully decoded--so that you can move or view files right away, and don't have to wait for all files to be decoded before you can do anything. Ready-made functions you can put in this list are:
  `gnus-uu-grab-view`
    View the file.
  `gnus-uu-grab-move`
    Move the file (if you're using a saving function.)
`gnus-uu-ignore-files-by-name`
  Files with name matching this regular expression won't be viewed.
`gnus-uu-ignore-files-by-type`
  Files with a MIME type matching this variable won't be viewed. Note that Gnus tries to guess what type the file is based on the name. `gnus-uu` is not a MIME package (yet), so this is slightly kludgey.
`gnus-uu-tmp-dir`
  Where `gnus-uu` does its work.
`gnus-uu-do-not-unpack-archives`
  Non-`nil` means that `gnus-uu` won't peek inside archives looking for files to display.
`gnus-uu-view-and-save`
  Non-`nil` means that the user will always be asked to save a file after viewing it.
`gnus-uu-ignore-default-view-rules`
  Non-`nil` means that `gnus-uu` will ignore the default viewing rules.
`gnus-uu-ignore-default-archive-rules`
  Non-`nil` means that `gnus-uu` will ignore the default archive unpacking commands.
`gnus-uu-kill-carriage-return`
  Non-`nil` means that `gnus-uu` will strip all carriage returns from articles.
`gnus-uu-unmark-articles-not-decoded`
  Non-`nil` means that `gnus-uu` will mark articles that were unsuccessfully decoded as unread.
`gnus-uu-correct-stripped-uucode`
  Non-`nil` means that `gnus-uu` will try to fix uuencoded files that have had trailing spaces deleted.
`gnus-uu-view-with-metamail`
  Non-`nil` means that `gnus-uu` will ignore the viewing commands defined by the rule variables and just fudge a MIME content type based on the file name. The result will be fed to `metamail` for viewing.
`gnus-uu-save-in-digest`
  Non-`nil` means that `gnus-uu`, when asked to save without decoding, will save in digests. If this variable is `nil`, `gnus-uu` will just save everything in a file without any embellishments. The digesting almost conforms to RFC1153--no easy way to specify any meaningful volume and issue numbers were found, so I simply dropped them.

#### Uuencoding and Posting

`gnus-uu-post-include-before-composing`
  Non-`nil` means that `gnus-uu` will ask for a file to encode before you compose the article. If this variable is `t`, you can either include an encoded file with `C-c C-i` or have one included for you when you post the article.
`gnus-uu-post-length`
  Maximum length of an article. The encoded file will be split into how many articles it takes to post the entire file.
`gnus-uu-post-threaded`
  Non-`nil` means that `gnus-uu` will post the encoded file in a thread. This may not be smart, as no other decoder I have seen are able to follow threads when collecting uuencoded articles. (Well, I have seen one package that does that---`gnus-uu`, but somehow, I don't think that counts...) Default is `nil`.
`gnus-uu-post-separate-description`
  Non-`nil` means that the description will be posted in a separate article. The first article will typically be numbered (0/x). If this variable is `nil`, the description the user enters will be included at the beginning of the first article, which will be numbered (1/x). Default is `t`.

### Viewing Files

After decoding, if the file is some sort of archive, Gnus will attempt to unpack the archive and see if any of the files in the archive can be viewed. For instance, if you have a gzipped tar file ``pics.tar.gz'` containing the files ``pic1.jpg'` and ``pic2.gif'`, Gnus will uncompress and de-tar the main file, and then view the two pictures. This unpacking process is recursive, so if the archive contains archives of archives, it'll all be unpacked.

Finally, Gnus will normally insert a pseudo-article for each extracted file into the summary buffer. If you go to these "articles", you will be prompted for a command to run (usually Gnus will make a suggestion), and then the command will be run.

If `gnus-view-pseudo-asynchronously` is `nil`, Emacs will wait until the viewing is done before proceeding.

If `gnus-view-pseudos` is `automatic`, Gnus will not insert the pseudo-articles into the summary buffer, but view them immediately. If this variable is `not-confirm`, the user won't even be asked for a confirmation before viewing is done.

If `gnus-view-pseudos-separately` is non-`nil`, one pseudo-article will be created for each file to be viewed. If `nil`, all files that use the same viewing command will be given as a list of parameters to that command.

If `gnus-insert-pseudo-articles` is non-`nil`, insert pseudo-articles when decoding. It is `t` by default.

So; there you are, reading your pseudo-articles in your virtual newsgroup from the virtual server; and you think: Why isn't anything real anymore? How did we get here?

## Article Treatment

Reading through this huge manual, you may have quite forgotten that the object of newsreaders are to actually, like, read what people have written. Reading articles. Unfortunately, people are quite bad at writing, so there are tons of functions and variables to make reading these articles easier.

- Article Highlighting: You want to make the article look like fruit salad.
- Article Hiding: You also want to make certain info go away.
- Article Washing: Lots of way-neat functions to make life better.
- Article Buttons: Click on URLs, Message-IDs, addresses and the like.
- Article Date: Grumble, UT!

### Article Highlighting

Not only do you want your article buffer to look like fruit salad, but you want it to look like technicolor fruit salad.

`W H a`
  Highlight the current article (`gnus-article-highlight`).
`W H h`
  Highlight the headers (`gnus-article-highlight-headers`). The highlighting will be done according to the `gnus-header-face-alist` variable, which is a list where each element has the form (regexp name content). regexp is a regular expression for matching the header, name is the face used for highlighting the header name and content is the face for highlighting the header value. The first match made will be used. Note that regexp shouldn't have ``^'` prepended--Gnus will add one.
`W H c`
  Highlight cited text (`gnus-article-highlight-citation`). Some variables to customize the citation highlights:
  `gnus-cite-parse-max-size`
    If the article size if bigger than this variable (which is 25000 by default), no citation highlighting will be performed.
  `gnus-cite-prefix-regexp`
    Regexp matching the longest possible citation prefix on a line.
  `gnus-cite-max-prefix`
    Maximum possible length for a citation prefix (default 20).
  `gnus-cite-face-list`
    List of faces used for highlighting citations. When there are citations from multiple articles in the same message, Gnus will try to give each citation from each article its own face. This should make it easier to see who wrote what.
  `gnus-supercite-regexp`
    Regexp matching normal Supercite attribution lines.
  `gnus-supercite-secondary-regexp`
    Regexp matching mangled Supercite attribution lines.
  `gnus-cite-minimum-match-count`
    Minimum number of identical prefixes we have to see before we believe that it's a citation.
  `gnus-cite-attribution-prefix`
    Regexp matching the beginning of an attribution line.
  `gnus-cite-attribution-suffix`
    Regexp matching the end of an attribution line.
  `gnus-cite-attribution-face`
    Face used for attribution lines. It is merged with the face for the cited text belonging to the attribution.
`W H s`
  Highlight the signature (`gnus-article-highlight-signature`). Everything after `gnus-signature-separator` in an article will be considered a signature and will be highlighted with `gnus-signature-face`, which is `italic` by default.

### Article Hiding

Or rather, hiding certain things in each article. There usually is much too much cruft in most articles.

`W W a`
  Do maximum hiding on the summary buffer (`gnus-article-hide`).
`W W h`
  Hide headers (`gnus-article-hide-headers`). See section Hiding Headers.
`W W b`
  Hide headers that aren't particularly interesting (`gnus-article-hide-boring-headers`). See section Hiding Headers.
`W W s`
  Hide signature (`gnus-article-hide-signature`).
`W W p`
  Hide PGP signatures (`gnus-article-hide-pgp`).
`W W c`
  Hide citation (`gnus-article-hide-citation`). Some variables for customizing the hiding:
  `gnus-cite-hide-percentage`
    If the cited text is of a bigger percentage than this variable (default 50), hide the cited text.
  `gnus-cite-hide-absolute`
    The cited text must be have at least this length (default 10) before it is hidden.
  `gnus-cited-text-button-line-format`
    Gnus adds buttons show where the cited text has been hidden, and to allow toggle hiding the text. The format of the variable is specified by this format-like variable. These specs are legal:
    ``b'`
      Start point of the hidden text.
    ``e'`
      End point of the hidden text.
    ``l'`
      Length of the hidden text.
  `gnus-cited-lines-visible`
    The number of lines at the beginning of the cited text to leave shown.
`W W C`
  Hide cited text in articles that aren't roots (`gnus-article-hide-citation-in-followups`). This isn't very useful as an interactive command, but might be a handy function to stick in `gnus-article-display-hook` (see section Customizing Articles).

All these "hiding" commands are toggles, but if you give a negative prefix to these commands, they will show what they have previously hidden. If you give a positive prefix, they will always hide.

Also see section Article Highlighting for further variables for citation customization.

`gnus-signature-limit` provides a limit to what is considered a signature. If it is a number, no signature may not be longer (in characters) than that number. If it is a function, the function will be called without any parameters, and if it returns `nil`, there is no signature in the buffer. If it is a string, it will be used as a regexp. If it matches, the text in question is not a signature.

### Article Washing

We call this "article washing" for a really good reason. Namely, the `A` key was taken, so we had to use the `W` key instead.

Washing is defined by us as "changing something from something to something else", but normally results in something looking better. Cleaner, perhaps.

`W l`
  Remove page breaks from the current article (`gnus-summary-stop-page-breaking`).
`W r`
  Do a Caesar rotate (rot13) on the article buffer (`gnus-summary-caesar-message`).
`W t`
  Toggle whether to display all headers in the article buffer (`gnus-summary-toggle-header`).
`W v`
  Toggle whether to display all headers in the article buffer permanently (`gnus-summary-verbose-header`).
`W m`
  Toggle whether to run the article through MIME before displaying (`gnus-summary-toggle-mime`).
`W o`
  Treat overstrike (`gnus-article-treat-overstrike`).
`W w`
  Do word wrap (`gnus-article-fill-cited-article`).
`W c`
  Remove CR (`gnus-article-remove-cr`).
`W L`
  Remove all blank lines at the end of the article (`gnus-article-remove-trailing-blank-lines`).
`W q`
  Treat quoted-printable (`gnus-article-de-quoted-unreadable`).
`W f`
  Look for and display any X-Face headers (`gnus-article-display-x-face`). The command executed by this function is given by the `gnus-article-x-face-command` variable. If this variable is a string, this string will be executed in a sub-shell. If it is a function, this function will be called with the face as the argument. If the `gnus-article-x-face-too-ugly` (which is a regexp) matches the `From` header, the face will not be shown. The default action under Emacs is to fork off an `xv` to view the face; under XEmacs the default action is to display the face before the `From` header. (It's nicer if XEmacs has been compiled with X-Face support -- that will make display somewhat faster. If there's no native X-Face support, Gnus will try to convert the `X-Face` header using external programs from the `pbmplus` package and friends.) If you want to have this function in the display hook, it should probably come last.
`W b`
  Add clickable buttons to the article (`gnus-article-add-buttons`).
`W B`
  Add clickable buttons to the article headers (`gnus-article-add-buttons-to-head`).

### Article Buttons

People often include references to other stuff in articles, and it would be nice if Gnus could just fetch whatever it is that people talk about with the minimum of fuzz.

Gnus adds buttons to certain standard references by default: Well-formed URLs, mail addresses and Message-IDs. This is controlled by two variables, one that handles article bodies and one that handles article heads:

`gnus-button-alist`
  This is an alist where each entry has this form:

      (REGEXP BUTTON-PAR USE-P FUNCTION DATA-PAR)

  regexp
    All text that match this regular expression will be considered an external reference. Here's a typical regexp that match embedded URLs: ``<URL:\\([^\n\r>]*\\)>'`.
  button-par
    Gnus has to know which parts of the match is to be highlighted. This is a number that says what sub-expression of the regexp that is to be highlighted. If you want it all highlighted, you use `0` here.
  use-p
    This form will be `eval`ed, and if the result is non-`nil`, this is considered a match. This is useful if you want extra sifting to avoid false matches.
  function
    This function will be called when you click on this button.
  data-par
    As with button-par, this is a sub-expression number, but this one says which part of the match is to be sent as data to function.
  So the full entry for buttonizing URLs is then

      ("<URL:\\([^\n\r>]*\\)>" 0 t gnus-button-url 1)

`gnus-header-button-alist`
  This is just like the other alist, except that it is applied to the article head only, and that each entry has an additional element that is used to say what headers to apply the buttonize coding to:

      (HEADER REGEXP BUTTON-PAR USE-P FUNCTION DATA-PAR)

  header is a regular expression.
`gnus-button-url-regexp`
  A regular expression that matches embedded URLs. It is used in the default values of the variables above.
`gnus-article-button-face`
  Face used on bottons.
`gnus-article-mouse-face`
  Face is used when the mouse cursor is over a button.

### Article Date

The date is most likely generated in some obscure timezone you've never heard of, so it's quite nice to be able to find out what the time was when the article was sent.

`W T u`
  Display the date in UT (aka. GMT, aka ZULU) (`gnus-article-date-ut`).
`W T l`
  Display the date in the local timezone (`gnus-article-date-local`).
`W T e`
  Say how much time has (e)lapsed between the article was posted and now (`gnus-article-date-lapsed`).
`W T o`
  Display the original date (`gnus-article-date-original`). This can be useful if you normally use some other conversion function and is worried that it might be doing something totally wrong. Say, claiming that the article was posted in 1854. Although something like that is totally impossible. Don't you trust me? *titter*

## Summary Sorting

You can have the summary buffer sorted in various ways, even though I can't really see why you'd want that.

`C-c C-s C-n`
  Sort by article number (`gnus-summary-sort-by-number`).
`C-c C-s C-a`
  Sort by author (`gnus-summary-sort-by-author`).
`C-c C-s C-s`
  Sort by subject (`gnus-summary-sort-by-subject`).
`C-c C-s C-d`
  Sort by date (`gnus-summary-sort-by-date`).
`C-c C-s C-i`
  Sort by score (`gnus-summary-sort-by-score`).

These functions will work both when you use threading and when you don't use threading. In the latter case, all summary lines will be sorted, line by line. In the former case, sorting will be done on a root-by-root basis, which might not be what you were looking for. To toggle whether to use threading, type `T T` (see section Thread Commands).

## Finding the Parent

If you'd like to read the parent of the current article, and it is not displayed in the summary buffer, you might still be able to. That is, if the current group is fetched by NNTP, the parent hasn't expired and the `References` in the current article are not mangled, you can just press `^` or `A r` (`gnus-summary-refer-parent-article`). If everything goes well, you'll get the parent. If the parent is already displayed in the summary buffer, point will just move to this article.

You can have Gnus fetch all articles mentioned in the `References` header of the article by pushing `A R` (`gnus-summary-refer-references`).

You can also ask the NNTP server for an arbitrary article, no matter what group it belongs to. `M-^` (`gnus-summary-refer-article`) will ask you for a `Message-ID`, which is one of those long thingies that look something like ``<38o6up$6f2@hymir.ifi.uio.no>'`. You have to get it all exactly right. No fuzzy searches, I'm afraid.

If the group you are reading is located on a backend that does not support fetching by `Message-ID` very well (like `nnspool`), you can set `gnus-refer-article-method` to an NNTP method. It would, perhaps, be best if the NNTP server you consult is the same as the one that keeps the spool you are reading from updated, but that's not really necessary.

Most of the mail backends support fetching by `Message-ID`, but do not do a particularly excellent job of it. That is, `nnmbox` and `nnbabyl` are able to locate articles from any groups, while `nnml` and `nnfolder` are only able to locate articles that have been posted to the current group. (Anything else would be too time consuming.) `nnmh` does not support this at all.

## Alternative Approaches

Different people like to read news using different methods. This being Gnus, we offer a small selection of minor modes for the summary buffers.

- Pick and Read: First mark articles and then read them.
- Binary Groups: Auto-decode all articles.

### Pick and Read

Some newsreaders (like `nn` and, uhm, `nn`) use a two-phased reading interface. The user first marks the articles she wants to read from a summary buffer. Then she starts reading the articles with just an article buffer displayed.

Gnus provides a summary buffer minor mode that allows this---`gnus-pick-mode`. This basically means that a few process mark commands become one-keystroke commands to allow easy marking, and it makes one additional command for switching to the summary buffer available.

Here are the available keystrokes when using pick mode:

`SPACE`
  Pick the article (`gnus-summary-mark-as-processable`).
`u`
  Unpick the article (`gnus-summary-unmark-as-processable`).
`U`
  Unpick all articles (`gnus-summary-unmark-all-processable`).
`t`
  Pick the thread (`gnus-uu-mark-thread`).
`T`
  Unpick the thread (`gnus-uu-unmark-thread`).
`r`
  Pick the region (`gnus-uu-mark-region`).
`R`
  Unpick the region (`gnus-uu-unmark-region`).
`e`
  Pick articles that match a regexp (`gnus-uu-mark-by-regexp`).
`E`
  Unpick articles that match a regexp (`gnus-uu-unmark-by-regexp`).
`b`
  Pick the buffer (`gnus-uu-mark-buffer`).
`B`
  Unpick the buffer (`gnus-uu-unmark-buffer`).
`RET`
  Start reading the picked articles (`gnus-pick-start-reading`). If given a prefix, mark all unpicked articles as read first. If `gnus-pick-display-summary` is non-`nil`, the summary buffer will still be visible when you are reading.

If this sounds like a good idea to you, you could say:

    (add-hook 'gnus-summary-mode-hook 'gnus-pick-mode)

`gnus-pick-mode-hook` is run in pick minor mode buffers.

### Binary Groups

If you spend much time in binary groups, you may grow tired of hitting `X u`, `n`, `RET` all the time. `M-x gnus-binary-mode` is a minor mode for summary buffers that makes all ordinary Gnus article selection functions uudecode series of articles and display the result instead of just displaying the articles the normal way.

In fact, the only way to see the actual articles if you have turned this mode on is the `g` command (`gnus-binary-show-article`).

`gnus-binary-mode-hook` is called in binary minor mode buffers.

## Tree Display

If you don't like the normal Gnus summary display, you might try setting `gnus-use-trees` to `t`. This will create (by default) an additional tree buffer. You can execute all summary mode commands in the tree buffer.

There are a few variables to customize the tree display, of course:

`gnus-tree-mode-hook`
  A hook called in all tree mode buffers.
`gnus-tree-mode-line-format`
  A format string for the mode bar in the tree mode buffers. The default is ``Gnus: %%b [%A] %Z'`. For a list of legal specs, see section Summary Buffer Mode Line.
`gnus-selected-tree-face`
  Face used for highlighting the selected article in the tree buffer. The default is `modeline`.
`gnus-tree-line-format`
  A format string for the tree nodes. The name is a bit of a misnomer, though--it doesn't define a line, but just the node. The default value is ``%(%[%3,3n%]%)'`, which displays the first three characters of the name of the poster. It is vital that all nodes are of the same length, so you must use ``%4,4n'`-like specifiers. Legal specs are:
  ``n'`
    The name of the poster.
  ``f'`
    The `From` header.
  ``N'`
    The number of the article.
  ``['`
    The opening bracket.
  ``]'`
    The closing bracket.
  ``s'`
    The subject.
  See section Formatting Variables. Variables related to the display are:
  `gnus-tree-brackets`
    This is used for differentiating between "real" articles and "sparse" articles. The format is ((real-open . real-close) (sparse-open . sparse-close) (dummy-open . dummy-close)), and the default is `((?[ . ?]) (?( . ?)) (?{ . ?}))`.
  `gnus-tree-parent-child-edges`
    This is a list that contains the characters used for connecting parent nodes to their children. The default is `(?- ?\\ ?|)`.
`gnus-tree-minimize-window`
  If this variable is non-`nil`, Gnus will try to keep the tree buffer as small as possible to allow more room for the other Gnus windows. If this variable is a number, the tree buffer will never be higher than that number. The default is `t`.
`gnus-generate-tree-function`
  The function that actually generates the thread tree. Two predefined functions are available: `gnus-generate-horizontal-tree` and `gnus-generate-vertical-tree` (which is the default).

Here's and example from a horizontal tree buffer:

    {***}-(***)-[odd]-[Gun]
         |     \[Jan]
         |     \[odd]-[Eri]
         |     \(***)-[Eri]
         |           \[odd]-[Paa]
         \[Bjo]
         \[Gun]
         \[Gun]-[Jor]

Here's the same thread displayed in a vertical tree buffer:

    {***}
      |--------------------------\-----\-----\
    (***)                         [Bjo] [Gun] [Gun]
      |--\-----\-----\                          |
    [odd] [Jan] [odd] (***)                   [Jor]
      |           |     |--\
    [Gun]       [Eri] [Eri] [odd]
                              |
                            [Paa]

## Mail Group Commands

Some commands only make sense in mail groups. If these commands are illegal in the current group, they will raise a hell and let you know.

All these commands (except the expiry and edit commands) use the process/prefix convention (see section Process/Prefix).

`B e`
  Expire all expirable articles in the group (`gnus-summary-expire-articles`).
`B M-C-e`
  Expunge all the expirable articles in the group (`gnus-summary-expire-articles-now`). This means that all articles that are eligible for expiry in the current group will disappear forever into that big ``/dev/null'` in the sky.
`B DEL`
  Delete the mail article. This is "delete" as in "delete it from your disk forever and ever, never to return again." Use with caution. (`gnus-summary-delete-article`).
`B m`
  Move the article from one mail group to another (`gnus-summary-move-article`).
`B c`
  Copy the article from one group (mail group or not) to a mail group (`gnus-summary-copy-article`).
`B C`
  Crosspost the current article to some other group (`gnus-summary-crosspost-article`). This will create a new copy of the article in the other group, and the Xref headers of the article will be properly updated.
`B i`
  Import an arbitrary file into the current mail newsgroup (`gnus-summary-import-article`). You will be prompted for a file name, a `From` header and a `Subject` header.
`B r`
  Respool the mail article (`gnus-summary-move-article`).
`B w`
`e`
  Edit the current article (`gnus-summary-edit-article`). To finish editing and make the changes permanent, type `C-c C-c` (`gnus-summary-edit-article-done`).
`B q`
  If you want to re-spool an article, you might be curious as to what group the article will end up in before you do the re-spooling. This command will tell you (`gnus-summary-respool-query`).

If you move (or copy) articles regularly, you might wish to have Gnus suggest where to put the articles. `gnus-move-split-methods` is a variable that uses the same syntax as `gnus-split-methods` (see section Saving Articles). You may customize that variable to create suggestions you find reasonable.

## Various Summary Stuff

- Summary Group Information: Information oriented commands.
- Searching for Articles: Multiple article commands.
- Really Various Summary Commands: Those pesky non-conformant commands.

`gnus-summary-mode-hook`
  This hook is called when creating a summary mode buffer.
`gnus-summary-generate-hook`
  This is called as the last thing before doing the threading and the generation of the summary buffer. It's quite convenient for customizing the threading variables based on what data the newsgroup has. This hook is called from the summary buffer after most summary buffer variables has been set.
`gnus-summary-prepare-hook`
  Is is called after the summary buffer has been generated. You might use it to, for instance, highlight lines or modify the look of the buffer in some other ungodly manner. I don't care.

### Summary Group Information

`H f`
  Try to fetch the FAQ (list of frequently asked questions) for the current group (`gnus-summary-fetch-faq`). Gnus will try to get the FAQ from `gnus-group-faq-directory`, which is usually a directory on a remote machine. This variable can also be a list of directories. In that case, giving a prefix to this command will allow you to choose between the various sites. `ange-ftp` probably will be used for fetching the file.
`H d`
  Give a brief description of the current group (`gnus-summary-describe-group`). If given a prefix, force rereading the description from the server.
`H h`
  Give a very brief description of the most important summary keystrokes (`gnus-summary-describe-briefly`).
`H i`
  Go to the Gnus info node (`gnus-info-find-node`).

### Searching for Articles

`M-s`
  Search through all subsequent articles for a regexp (`gnus-summary-search-article-forward`).
`M-r`
  Search through all previous articles for a regexp (`gnus-summary-search-article-backward`).
`&`
  This command will prompt you for a header field, a regular expression to match on this field, and a command to be executed if the match is made (`gnus-summary-execute-command`).
`M-&`
  Perform any operation on all articles that have been marked with the process mark (`gnus-summary-universal-argument`).

### Really Various Summary Commands

`A D`
  If the current article is a collection of other articles (for instance, a digest), you might use this command to enter a group based on the that article (`gnus-summary-enter-digest-group`). Gnus will try to guess what article type is currently displayed unless you give a prefix to this command, which forces a "digest" interpretation. Basically, whenever you see a message that is a collection of other messages on some format, you `A D` and read these messages in a more convenient fashion.
`C-t`
  Toggle truncation of summary lines (`gnus-summary-toggle-truncation`).
`=`
  Expand the summary buffer window (`gnus-summary-expand-window`). If given a prefix, force an `article` window configuration.

## Exiting the Summary Buffer

Exiting from the summary buffer will normally update all info on the group and return you to the group buffer.

`Z Z`
`q`
  Exit the current group and update all information on the group (`gnus-summary-exit`). `gnus-summary-prepare-exit-hook` is called before doing much of the exiting, and calls `gnus-summary-expire-articles` by default. `gnus-summary-exit-hook` is called after finishing the exiting process.
`Z E`
`Q`
  Exit the current group without updating any information on the group (`gnus-summary-exit-no-update`).
`Z c`
`c`
  Mark all unticked articles in the group as read and then exit (`gnus-summary-catchup-and-exit`).
`Z C`
  Mark all articles, even the ticked ones, as read and then exit (`gnus-summary-catchup-all-and-exit`).
`Z n`
  Mark all articles as read and go to the next group (`gnus-summary-catchup-and-goto-next-group`).
`Z R`
  Exit this group, and then enter it again (`gnus-summary-reselect-current-group`). If given a prefix, select all articles, both read and unread.
`Z G`
`M-g`
  Exit the group, check for new articles in the group, and select the group (`gnus-summary-rescan-group`). If given a prefix, select all articles, both read and unread.
`Z N`
  Exit the group and go to the next group (`gnus-summary-next-group`).
`Z P`
  Exit the group and go to the previous group (`gnus-summary-prev-group`).

`gnus-exit-group-hook` is called when you exit the current group.

If you're in the habit of exiting groups, and then changing your mind about it, you might set `gnus-kill-summary-on-exit` to `nil`. If you do that, Gnus won't kill the summary buffer when you exit it. (Quelle surprise!) Instead it will change the name of the buffer to something like ``*Dead Summary ... *'` and install a minor mode called `gnus-dead-summary-mode`. Now, if you switch back to this buffer, you'll find that all keys are mapped to a function called `gnus-summary-wake-up-the-dead`. So tapping any keys in a dead summary buffer will result in a live, normal summary buffer.

There will never be more than one dead summary buffer at any one time.

The data on the current group will be updated (which articles you have read, which articles you have replied to, etc.) when you exit the summary buffer. If the `gnus-use-cross-reference` variable is `t` (which is the default), articles that are cross-referenced to this group and are marked as read, will also be marked as read in the other subscribed groups they were cross-posted to. If this variable is neither `nil` nor `t`, the article will be marked as read in both subscribed and unsubscribed groups.

Marking cross-posted articles as read ensures that you'll never have to read the same article more than once. Unless, of course, somebody has posted it to several groups separately. Posting the same article to several groups (not cross-posting) is called spamming, and you are by law required to send nasty-grams to anyone who perpetrates such a heinous crime.

Remember: Cross-posting is kinda ok, but posting the same article separately to several groups is not. Massive cross-posting (aka. velveeta) is to be avoided.

One thing that may cause Gnus to not do the cross-posting thing correctly is if you use an NNTP server that supports XOVER (which is very nice, because it speeds things up considerably) which does not include the `Xref` header in its NOV lines. This is Evil, but all too common, alas, alack. Gnus tries to Do The Right Thing even with XOVER by registering the `Xref` lines of all articles you actually read, but if you kill the articles, or just mark them as read without reading them, Gnus will not get a chance to snoop the `Xref` lines out of these articles, and will be unable to use the cross reference mechanism.

To check whether your NNTP server includes the `Xref` header in its overview files, try ``telnet your.nntp.server nntp'`, ``MODE READER'` on `inn` servers, and then say ``LIST overview.fmt'`. This may not work, but if it does, and the last line you get does not read ``Xref:full'`, then you should shout and whine at your news admin until she includes the `Xref` header in the overview files.

If you want Gnus to get the `Xref`s right all the time, you have to set `gnus-nov-is-evil` to `t`, which slows things down considerably.

C'est la vie.

Go to the first, previous, next, last section, table of contents.