This file documents Gnus, the GNU Emacs newsreader.

Copyright (C) 1995 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.

The Gnus Newsreader
*******************

You can read news (and mail) from within Emacs by using Gnus.  The news can be gotten by any nefarious means you can think of - NNTP, local spool or your mbox file.  All at the same time, if you want to push your luck.

This manual hasn't been prperly proff-read yet, so typos abound, and misleading information is sure to exist.

History
*******

GNUS was written by Masanobu UMEDA.  When autumn crept up in '94, Lars Magne Ingebrigtsen grew bored and decided to rewrite Gnus.

The recommended pronounciation of the name this program is "ding guh-noose", with "ding" being half-sung in a loud, high-pitched voice, and "guh-noose" being grumbled and a disaffected fashion.  Any irritation and/or damage this name may cause you is not the responsibility of the author, even though you might like to strangle him for the stupid idea.

If you want to investigate the person responsible for this outrage, you can point your (feh!) web browser to http://www.ifi.uio.no/~larsi/.  This is also the primary distribution point for the new and spiffy versions of Gnus, also know as The Site That Destroys Newsrcs And Drives People Mad.

(ding), is, of course, short for ding is not Gnus, which is a total and utter lie, but who cares? (Besides, the "Gnus" in this abbreviation should probably be pronounced "news" as UMEDA intended, which makes it a more appropriate name, don't you think?)

Compatibility
=============

(ding) Gnus was designed to be fully compatible with GNUS.  Almost all key bindings have been kept.  More key bindings have been added, of course, but only in one or two obscure cases have old bindings been changed.

Our motto is:

     In a cloud bones of steel.

All commands have kept their names.  Some internal functions have changed their names.

The gnus-uu package has changed drastically. See Decoding Articles.

One major compatability question if the presence of several summary buffers.  All variables that are relevant while reading a group are buffer-local to the summary buffer they belong in.  Although most important variables have their values copied into their global counterparts whenever a command is executed in the summary buffer, this change might lead to incorrect values being used unless you are careful.

All code that relies on knowledge of GNUS internals will probably fail.  To take two examples: Sorting gnus-newsrc-assoc (or changing it in any way, as a matter of fact) is strictly verboten.  Gnus maintains a hash table that points to the entries in this assoc (which speeds up many functions), and changing the assoc directly will lead to peculiar results.

Old hilit19 code does not work at all.  In fact, you should probably remove all hihit code from all Gnus hooks (gnus-group-prepare-hook, gnus-summary-prepare-hook and gnus-summary-article-hook).  (Well, at the very least the first two.)  Gnus provides various integrated functions for highlighting. These are faster and more accurate.

Packages like expire-kill will no longer work.  As a matter of fact, you should probably remove all old GNUS packages (and other code) when you start using (ding) Gnus.  More likely than not, (ding) Gnus already does what you have written code to make GNUS do. (Snicker.)

Even though old methods of doing things are still supported, only the new methods are documented in this manual.  If you detect a new method of doing something while reading this manual, that does not mean you have to stop doing it the old way.

(ding) Gnus understands all GNUS startup files.

Overall, a casual user who hasn't written much code that depends on GNUS internals should suffer no problems.  If problems occur, please let me know (M-x gnus-bug).

Problems specific to GNU XEmacs can be reported to popineau@ese-metz.fr (Fabrice Popineau).  I will just forward any such questions to him, anyway, so you might have to wait longer if you mail XEmacs questions to me.

Contributors
============

The new Gnus version couldn't have been done without the help of all the people on the (ding) mailing list.  Every day for months I have gotten tens of nice bug reports from them, filling me with joy, every single one of them.  Smooches.  The people on the list have been tried beyond endurance, what with my "oh, that's a neat idea <type type>, yup, I'll release it right away <ship off> no wait, that doesn't work at all <type type>, yup, I'll ship that one off right away <ship off> no, wait, that aboslutely does not work" policy for releases.  Microsoft - bah.  I'm much worse.

I would like to take this opportunity to thank the Academy for...  oops, wrong show.

  * Of course, GNUS was written by Masanobu UMEDA.

  * Many excellent functions, especially dealing with scoring and highlighting (as well as the soon-to-come SOUP support) was written by Per Abrahamsen.

  * Innumarable bug fixes were written by Sudish Joseph.

  * I stole some pieces from the XGnus distribution by Felix Lee and JWZ.

  * nnfolder has been much enhanced by Scott Byer.

  * The orphan scoring was written by Peter Mutsaers.

  * GNU XEmacs support has been added by Fabrice Popineau.

  * Various bits and pieces, especially dealing with .newsrc files, was suggested and added by Hallvard B Furuseth.

  * Brian Edmonds has written gnus-bbdb, as well as other bits and pieces.

  * Stainless Steel Rat, Jack Vinson, Daniel Quinlan, Ilja Weis and Andrew Eskilsson have all contributed code and suggestions.

Gnus & hilit
============

gnus-visual can be used to highlight the summary buffer.  It offers far more flexibility than hilit (since it has access to more data; eg. the article score) in deciding how to highlight a given article.  Also, hilit gets confused by the way Gnus manipulates the summary buffer, leading to errors.  Such errors may be detected by looking for any hilit-specific functions in the *Backtrace* buffer.  If such a reference exists, you should be using the code below.

On the other hand, gnus-visual makes no attempt to highlight the article buffer, while hilit does a very good job of this.  There is a compatibility problem here though, since hilit uses gnus-article-prepare-hook to do its magic.  This hook is executed before headers are hidden, via gnus-article-hide-headers-if-wanted which is run from gnus-article-display-hook.  The act of hiding the headers undoes all of the hilighting already done.  A similar effect occured in vanilla GNUS 4.1 if gnus-show-mime was set to t, since MIME processing, too, is done after this hook is executed.

The solution here is to use gnus-article-display-hook for highlighting (and for all purposes where you used gnus-article-prepare-hook earlier).  This hook is run after MIME processing, and is the last thing done before actually displaying the article.  Add the code below to your .gnus file to get the right functions onto the right hooks.

     (add-hook 'gnus-startup-hook
               '(lambda ()
                  ;; gnus-visual is far better for summary highlighting
                  ;; also, hilit cannot handle a (ding) summary and will
                  ;; crash on you
                  (remove-hook 'gnus-summary-prepare-hook
                               'hilit-rehighlight-buffer-quietly)
                  (remove-hook 'gnus-summary-prepare-hook 'hilit-install-line-hooks)
                  ;; this is too early for the purpose of highlighting
                  (remove-hook 'gnus-article-prepare-hook
                               'hilit-rehighlight-buffer-quietly)
                  ;; use this instead.  note that the final t is *essential*,
                  ;; this must be the last thing done
                  (add-hook 'gnus-article-display-hook
                            'hilit-rehighlight-buffer-quietly t)))

New Features
============

The look of all buffers can be changed by setting format-like variables.

Local spool and several NNTP servers can be used at once.  Virtual groups and private mail groups are featured.

Gnus can use various strategies for gathering threads that have lost their roots (thereby gathering loose sub-threads in one thread) or it can go back and retrieve enough headers to build a complete thread.

Killed groups can be displayed in the group buffer, and you can read them as well.

Gnus can do partial group updates - you do not have to retrieve the entire active file just to check for new articles in a few groups.

Gnus implements a sliding scale of subscribedness to groups.

The approach to killing has been changed.  Instead of simply killing or not, you can score articles for easier reading.

Newest Features
===============

Also known as the todo list.  Sure to be implemented before the next millennium.

  * Asynchronous article and header fetching would be very nice.  Pleasant. Even useful.  I might even have come up with an idea as to how to implement it (two connections, a bit run-at-time, and lots of glue), but this will probably not be implemented within the next few months.  In fact, I would put money on it not being implemented before (ding) is released, so this is more for Gnus 6.0.  Asynchronous posting, however, could possibly be included much sooner, as it is a separate issue.

  * Native MIME support is something that should be done.  I was hoping I could steal code from Mew, the MIME mail reader for Emacs, but I'm not quite sure what the status of that project is.  (ding) might support MIME quite soon, and it might not.

  * Some form of caching would come in handy.  Not only for those with extremely slow NNTP connections, but as a more general way of saving articles in a simple fashion.  (You'd basically just mark an article as cached.  Gnus would put it in some local directory, and each time you request that article from that group, Gnus would fetch the local copy instead.)  Lots of quite interesting stuff to be considered (caching NOV headers or not?) before jumping into it.  It would require much twiddling of Gnus internals to make it work transparently.

  * Gnus could detect which articles in you read and which articles you kill, and then employ some adaptive scoring scheme.  That could potentially be quite interesting, and it's easy enough to implement.

  * When the user references the parent of an article, some sort of re-threading should be done to build a proper tree.  The same goes for article expunging.  However, as it stands, it's not a trivial issue to re-generate parts of the summary buffer.  Generating the entire buffer is very easy, but slow.

Terminology
***********

news
     This is what you are supposed to use this thing for - reading news. News is generally fetched from a nearby NNTP server, and is generally publicly available to everybody.  If you post news, the entire world is likely to read just what you have written, and they'll all snigger mischievously.  Behind your back.

mail
     Everything that's delivered to you personally is mail.  Some news/mail readers (like Gnus) blur the distinction between mail and news, but there is a difference.  Mail is private.  News is public.  Mailing is not posting, and replying is not following up.

reply
     Send a mail to the person who has written what you are reading.

follow up
     Post an article to the current newsgroup responding to the article you are reading.

backend
     Gnus gets fed articles from a number of backends, both news and mail backends.  Gnus does not handle the underlying media, so to speak - this is all done by the backends.

native
     Gnus will always use one method (and backend) as the native, or default, way of getting news.

foreign
     You can also have any number of foreign groups at the same time.  These are groups that use different backends for getting news.

head
     The top part of an article, where administration information (etc.) is put.

body
     The rest of an article. Everything that is not in the head is in the body.

header
     A line from the head of an article.

headers
     A collection of such lines, or a collection of heads.  Or even a collection of NOV lines.

NOV
     When Gnus enters a group, it asks the backend for the headers for all the unread articles in the group.  Most servers support the News OverView format, which is much smaller and much faster to read than the normal HEAD format.

level
     Each group is subscribed at some level or other (1-9).  The ones that have a lower level are "more" subscribed than the groups with a higher level.  In fact, groups on levels 1-5 are considered subscribed; 6-7 are unsubscribed; 8 are zombies; and 9 are killed.  Commands for listing groups and scanning for new articles will all use the numeric prefix as working level.

killed groups
     No information on killed groups is stored or updated, which makes killed groups much easier to handle than subscribed groups.

zombie groups
     Just like killed groups, only slightly less dead.

active file
     The news server has to keep track of what articles it carries, and what groups exist.  All this information in stored in the active file, which is rather large, as you might surmise.

Starting Gnus
*************

If your system administrator has set things up properly, starting Gnus and reading news is extremely easy - you just type M-x gnus.

If things do not go smoothly at startup, you have to twiddle some variables.

Finding the News
================

The gnus-select-method variable controls how Gnus finds news. This variable should be a list where the first element says how and the second element says where.  This method is is your native method.  All groups that are not fetched with this method are foreign groups.

For instance, if you want to get your daily dosage of news from the news.somewhere.edu NNTP server, you'd say:

     (setq gnus-select-method '(nntp "news.somewhere.edu"))

If you want to read directly from the local spool, say:

     (setq gnus-select-method '(nnspool ""))

If you can use a local spool, you probably should, as it will almost certainly be much faster.

If this variable is not set, Gnus will take a look at the NNTPSERVER environment variable.  If that isn't set either, it will try to use the machine that is running Emacs as an NNTP server.

If gnus-nntp-server is set, this variable will override gnus-select-method.  You should therefore set gnus-nntp-server to nil, which is what it is by default.

You can also make Gnus prompt you interactively for the name of an NNTP server.  If you give a non-numerical prefix to gnus (ie. C-u M-x gnus), Gnus will let you choose between the servers in the gnus-secondary-servers list (if any).  You can also just type in the name of any server you feel like visiting.

However, if you use one NNTP server regularly, and are just interested in a couple of groups from a different server, you would be better served by using the gnus-group-browse-foreign-server command from the group buffer.  It will let you have a look at what groups are available, and you can subscribe to any of the groups you want to.  This also makes .newsrc maintenance much tidier. See Foreign Groups.

A slightly different approach to foreign groups is to set the gnus-secondary-select-methods variable.  The select methods listed in this variable are in many ways just as native as the gnus-select-method server.  They will also be queried for active files during startup (if that's required), and new newsgroups that appear on these servers will be subscribed (or not) just as native groups are.

For instance, if you use the nnmbox backend to read you mail, you would typically set this variable to

     (setq gnus-secondary-select-methods '((nnmbox "")))

The First Time
==============

If no startup files exist, Gnus will try to determine what groups should be subscribed by default.

If the variable gnus-default-subscribed-newsgroups is set, Gnus will subscribe you to just those groups in that list, leaving the rest killed.  Your system administrator should have set this variable to something useful.

Since she hasn't, Gnus will just subscribe you to a few randomly picked groups (ie. *.newusers).  (Random is here defined as "whatever Lars thinks you should read".)

You'll also be subscribed to the Gnus documentation group, which should help you with most common problems.

If gnus-default-subscribed-newsgroups is t, Gnus will just use the normal functions for handling new groups, and not do anything special.

The Server is Down
==================

If the default server is down, Gnus will understandably have some problems starting.  However, if you have some mail groups in addition to the news groups, you may want to start Gnus anyway.

Gnus, being the trusting sort of program, will ask whether to proceed without a native select method if that server can't be contacted.  This will happen whether the server doesn't actually exist (ie. you have given the wrong address) or the server has just momentarily taken ill for some reason or other.

If Gnus says "nntp server on <your server> can't be opened. Continue?", you do not want to continue unless you have some foreign groups that you want to read.  Even if you don't, Gnus will let you continue, but you'll find it difficult to actually do anything in the group buffer.  But, hey, that's your problem.  Blllrph!

New Groups
==========

What Gnus does when it encounters a new group is determined by the gnus-subscribe-newsgroup-method variable.

This variable should contain a function.  Some handy pre-fab values are:

gnus-subscribe-randomly
     Subscribe all new groups randomly.

gnus-subscribe-alphabetically
     Subscribe all new groups alphabetically.

gnus-subscribe-hierarchically
     Subscribe all new groups hierarchially.

gnus-subscribe-interactively
     Subscribe new groups interactively.  This means that Gnus will ask you about all new groups.

gnus-subscribe-zombies
     Make all new groups zombies.  You can browse the zombies later and either kill them all off properly, or subscribe to them.  This is the default.

A closely related variable is gnus-subscribe-hierarchical-interactive.  (That's quite a mouthful.)  If this variable is non-nil, Gnus will ask you in a hierarchial fashion whether to subscribe to new groups or not.  Gnus will ask you for each sub-hierarchy whether you want to descend the hierarchy or not.

One common way to control which new newsgroups should be subscribed or ignored is to put an options line at the start of the .newsrc file.  Here's an example:

     options -n !alt.all !rec.all sci.all

This line obviously belongs to a serious-minded intellectual scientific person (or she may just be plain old boring), because it says that all groups that have names beginning with alt and rec should be ignored, and all groups with names beginning with sci should be subscribed.  Gnus will not use the normal subscription method for subscribing these groups. gnus-subscribe-options-newsgroup-method is used instead.  This variable defaults to gnus-subscribe-alphabetically.

If you don't want to mess with your .newsrc file, you can just set the two variables gnus-options-subscribe and gnus-options-not-subscribe.  These two variables do exactly the same as the .newsrc options -n trick.  Both are regexps, and if the the new group matches the first, it will be unconditionally subscribed, and if it matches the latter, it will be ignored.

If you are satisfied that you really never want to see any new groups, you could set gnus-check-new-newsgroups to nil.  This will also save you some time at startup.  Even if this variable is nil, you can always subscribe to the new groups just by pressing U in the group buffer (see Group Maintenance).

Gnus normally determines whether a group is new or not by comparing the list of groups from the active file(s) with the lists of subscribed and dead groups.  This isn't a particularly fast method.  If gnus-check-new-newsgroups is ask-server, Gnus will ask the server for new groups since the last time.  This is both faster & cheaper.  This also means that you can get rid of the list of killed groups altogether, so you may set gnus-save-killed-list to nil, which will save time both at startup, at exit, and all over. Saves disk space, too.  Why isn't this the default, then? Unfortunately, not all servers support this function.

This variable can also be a list of select methods.  If so, Gnus will issue an ask-server command to each of the select methods, and subscribe them (or not) using the normal methods.  This might be handy if you are monitoring a few servers for new groups.  A side effect is that startup will take much longer, so you can meditate while waiting. Use the mantra "dingnusdingnusdingnus" to achieve permanent happiness.

Startup Files
=============

Now, you all know about the .newsrc file.  All subscription information is traditionally stored in this file.

Things got a bit more complicated with GNUS.  In addition to keeping the .newsrc file updated, it also used a file called .newsrc.el for storing all the information that didn't fit into the .newsrc file.  (Actually, it duplicated everything in the .newsrc file.)  GNUS would read whichever one of these files that were the most recently saved, which enabled people to swap between GNUS and other newsreaders.

That was kinda silly, so (ding) Gnus went one better: In addition to the .newsrc and .newsrc.el files, (ding) Gnus also has a file called .newsrc.eld.  It will read whichever of these files that are most recent, but it will never write a .newsrc.el file.

You can also turn off writing the .newsrc file by setting gnus-save-newsrc-file to nil, which means you can delete the file and save some space, as well as making exit from Gnus faster. However, this will make it impossible to use other newsreaders than Gnus.  But hey, who would want to, right?

If gnus-save-killed-list is nil, Gnus will not save the list of killed groups to the startup file.  This will save both time (when starting and quitting) and space (on disk).  It will also means that Gnus has no record of what groups are new or old, so the automatic new groups subscription methods become meaningless.  You should always set gnus-check-new-newsgroups to nil or ask-server if you set this variable to nil (see New Groups).

The gnus-startup-file variable says where the startup files are. The default value is ~/.newsrc, with the Gnus (El Dingo) startup file being whatever that one is with a .eld appended.

gnus-save-newsrc-hook is called before saving the .newsrc file.

Auto Save
=========

Whenever you do something that changes the Gnus data (reading articles, cathing up, killing/subscribing groups), the change is added to a special dribble buffer.  This buffer is auto-saved the normal Emacs way.  If your Emacs should crash before you have saved the .newsrc files, all changes you have made can be recovered from this file.

If Gnus detects this file at startup, it will ask the user whether to read it. The auto save file is deleted whenever the real startup file is saved.

If gnus-use-dribble-file is nil, Gnus won't create and maintain a dribble buffer.

The Active File
===============

When Gnus starts, or indeed whenever it tries to determine whether new articles have arrived, it reads the active file.  This is a very large file that lists all the active groups and articles on the NNTP server.

Before examining the active file, Gnus deletes all lines that match the regexp gnus-ignored-newsgroups.  This is done primarily to reject any groups with bogus names (eg. groups containing characters like '[]" and so on), but you can use this variable to make Gnus ignore hierarchies you aren't ever interested in.

The active file can be rather Huge, so if you have a slow network, you can set gnus-read-active-file to nil to prevent Gnus from reading the active file.

Gnus will try to make do by just getting information on the groups that you actually subscribe to.

Note that if you subscribe to lots and lots of groups, setting this variable to nil will probabaly make Gnus slower, not faster.  At present, having this variable nil will slow Gnus down considerably, unless you read news over a 2400 baud modem.

This variable can also have the value some.  Gnus will then attempt to read active info only on the subscribed groups.  On some servers this is quite fast (on sparkling, brand new INN servers that support the LIST ACTIVE group command), on others this is not fast at all.  In any case, some should be faster than nil, and is certainly faster than t over slow lines.

If this variable is nil, Gnus will as for group info in total lock-step, which isn't very fast.  If it is some and you use an NNTP server, Gnus will pump out commands as fast as it can, and read all the replies in one swoop.  This will normally result in better performance, but if the server does not support the aforementioned LIST ACTIVE group command, this isn't very nice to the server.

In any case, if you use some or nil, you should kill all groups that you aren't interested in.

Startup Variables
=================

gnus-check-bogus-newsgroups
     If non-nil, Gnus will check for and delete all bogus groups at startup.  A bogus group is a group that you have in your .newsrc file, but doesn't exist on the news server.  Checking for bogus groups isn't very quick, so to save time and resources, it's best to leave this option off, and instead do the checking for bogus groups once in a while from the group buffer (see Group Maintenance).

gnus-inhibit-startup-message
     If non-nil, the startup message won't be displayed.  That way, your boss might not notice thay you are reading news instead of doing your job.

gnus-no-groups-message
     Message displayed by Gnus when no groups are available.

The Group Buffer
****************

The group buffer lists all (or parts) of the available groups.  It is the first buffer shown when Gnus starts, and will never be killed as long as Gnus is active.

Group Buffer Format
===================

The default format of the group buffer is nice and dull, but you can make it as exciting and ugly as you feel like.

Here's a couple of example group lines:

          25: news.announce.newusers
      *    0: alt.fan.andrea-dworkin

Quite simple, huh?

You can see that there are 25 unread articles in news.announce.newusers.  There are no unread articles, but some ticked articles, in alt.fan.andrea-dworkin (see that little asterisk at the beginning of the line?)

You can fuck that up to your heart's delight by fiddling with the gnus-group-line-format variable.  This variable works along the lines of a format specification, which is pretty much the same as a printf specifications, for those of you who use (feh!) C.

In addition to the normal "padding" specs that format supports (eg. %7d), specifications like %7,12s are allowed.  A spec of this type means that the field will be at least 7 characters long, and never more that 12 characters long.

The default value that produced those lines above is "%M%S%5y: %(%g%)\n".

There should always be a colon on the line; the cursor always moves to the colon after performing an operation.  Nothing else is required - not even the group name.  All displayed text is just window dressing, and is never examined by Gnus.  Gnus stores all real information it needs using text properties.

(Note that if you make a really strange, wonderful, spreadsheat-like layout, everybody will believe you are hard at work with the accounting instead of wasting time reading news.)

Here's a list of all available format characters:

M
     Only marked articles.

S
     Whether the group is subscribed.

L
     Level of subscribedness.

N
     Number of unread articles.

I
     Number of dormant articles.

T
     Number of ticked articles.

R
     Number of read articles.

t
     Total number of articles.

y
     Number of unread, unticked, non-dormant articles.

i
     Number of ticked and dormant articles.

g
     Full group name.

G
     Group name.

D
     Newsgroup description.

o
     Moderated.

O
     Moderated.

s
     Select method.

n
     Select from where.

z
     A string that looks like <%s:%n> if a foreign select method is used.

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 headers as argument.  The function should return a string, which will be inserted into the buffer just like information from any other specifier.

The mode line can be changed by setting (gnus-group-mode-line-format).  It doesn't understand that many format specifiers:

S
     Default news server.

M
     Default select method.

Group Manouvering
=================

All movement commands understand the numeric prefix and will behave as expected, hopefully.

n
     Go to the next group that has unread articles (gnus-group-next-unread-group).

p
DEL
     Go to the previous group group that has unread articles (gnus-group-prev-unread-group).

N
     Go to the next group (gnus-group-next-group).

P
     Go to the previous group (gnus-group-prev-group).

M-p
     Go to the next unread group on the same level (or lower) (gnus-group-next-unread-group-same-level).

M-n
     Go to the previous unread group on the same level (or lower) (gnus-group-prev-unread-group-same-level).

Three commands for jumping to groups:

j
     Jump to a group (and make it visible if it isn't already) (gnus-group-jump-to-group).  Killed groups can be jumped to, just like living groups.

,
     Jump to the unread group with the lowest level (gnus-group-best-unread-group).

.
     Jump to the first group with unread articles (gnus-group-first-unread-group).

Selecting a Group
=================

SPACE
     Select the current group, switch to the summary buffer and display the first unread article (gnus-group-read-group).  If there are no unread articles in the group, or if you give a prefix to this command, Gnus will offer to fetch all the old articles in this group from the server.

RET
     Select the current group and switch to the summary buffer (gnus-group-select-group).  If you give a prefix to this command, Gnus will fetch all available articles in this group.

c
     Mark all unticked articles in this group as read (gnus-group-catchup-current).

C
     Mark all articles in this group, even the ticked ones, as read (gnus-group-catchup-current-all).

The gnus-large-newsgroup variable says what Gnus should consider to be a big group.  If the group has more unread articles than this, Gnus will query the user before entering the group.  The user can then specify how many articles should be fetched from the server.  If the user specifies a negative number (-n), the n oldest articles will be fetched.  If it is positive, the n articles that have arrived most recently will be fetched.

If gnus-auto-select-newsgroup is non-nil, the first unread article in the group will be displayed when you enter the group.  If you want to prevent automatic selection in some group (say, in a binary group with Huge articles) you can set this variable to nil in gnus-select-group-hook, which is called when a group is selected.

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 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, 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.  If you use more than one function, the primary sort key should be the last function in the list.

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

     (setq gnus-thread-sort-functions
           '(gnus-thread-sort-by-date
             gnus-thread-sort-by-subject
             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 you fancy.

Group Subscribing
=================

S t
u
     Toggle subscription to the current group (gnus-group-unsubscribe-current-group).

S s
U
     Prompt for a group to subscribe, and then subscribe it.  If it was subscribed already, unsubscribe it instead (gnus-group-unsubscribe-group).

S k
C-k
     Kill the current group (gnus-group-kill-group).

S y
C-y
     Yank the last killed group (gnus-group-yank-group).

S w
C-w
     Kill all groups in the region (gnus-group-kill-region).

S z
     Kill all zombie groups (gnus-group-kill-all-zombies).

Group Levels
============

All groups have a level of subscribedness.  For instance, if a group is on level 2, it is more subscribed than a group on level 5.  You can ask Gnus to just list groups on a given level or lower (see Listing Groups), or to just check for new articles in groups on a given level or lower (see Misc Group Stuff).

S l
     Set the level of the current group depending on the numeric prefix.  For instance, 3 S l will set the level of the current group to three (gnus-group-set-current-level).  If no numeric prefix is given, this command will prompt the user for a level.

Gnus considers groups on between levels 1 and gnus-level-subscribed (inclusive) to be subscribed, gnus-level-subscribed (ecxlusive) and gnus-level-unsubscribed (inclusive) to be unsubscribed, gnus-level-zombie to be zombies (walking dead) and gnus-level-killed to be killed, completely dead.  Gnus treats subscribed and unsubscribed groups exactly the same, but zombie and killed groups have no information on what articles you have read, etc, stored.  This distinction between dead and living groups isn't done because it is nice or clever, it is done purely for reasons of efficiency.

It is recommended that you keep all your mail groups (if any) on quite low levels (eg. 1 or 2).

If you want to play with the level variables, you should show some care. Set them once, and don't touch them ever again.

Two closely related variables are gnus-level-default-subscribed and gnus-level-default-unsubscribed, which are the leves that new groups will be put on if they are (un)subscribed.  These two variables should, of course, be inside the relevant legal ranges.

If gnus-keep-same-level is non-nil, some movement commands will only move to groups that are of the same level (or lower).  In particular, going from the last article in one group to the next group will go to the next group of the same level (or lower).  This might be handy if you want to read the most important groups before you read the rest.

All groups with a level less than or equal to gnus-group-default-list-level will be listed in the group buffer by default.

Foreign Groups
==============

A foreign group is a group that is not read by the usual (or default) means.  It could be, for instance, a group from a different NNTP server, it could be a virtual group, or it could be your own personal mail group.

A foreign group (or any group, really) is specified by a name and a select method.  To take the latter first, a select method is a list where the first element says what backend to use (eg. nntp, nnspool, nnml) and the second element is the server name.  There may be additional elements in the select method, where the value may have special meaning for the backend in question.

One could say that a select method defines a virtual server - so we do just that (see The Server Buffer).

The name of the group is the name the backend will recognize the group as.

For instance, the group soc.motss on the NNTP server some.where.edu will have the name soc.motss and select method (nntp "some.where.edu").  Gnus will call this group, in all circumstances, nntp+some.where.edu:soc.motss, even though the nntp backend just knows this group as soc.motss.

Here are some commands for making and editing general foreign groups, and some commands to ease the creation of some special-purpose groups:

M m
     Make a new group (gnus-group-make-group).  Gnus will prompt you for a name, a method and possibly an address.  For an easier way to subscribe to NNTP groups, see Browse Foreign Server.

M e
     Enter a buffer where you can edit the select method of the current group (gnus-group-edit-group-method).

M p
     Enter a buffer where you can edit the group parameters (gnus-group-edit-group-parameters).

M E
     Enter a buffer where you can edit the group info (gnus-group-edit-group).

M d
     Make a directory group.  You will be prompted for a directory name (gnus-group-make-directory-group).

M h
     Make the (ding) Gnus help group (gnus-group-make-help-group).

M a
     Make the (ding) Gnus archive group (gnus-group-make-archive-group).  The archive group will be fetched from gnus-group-archive-directory.

M k
     Make a kiboze group.  You will be prompted for a name, for a regexp to match groups to be "included" in the kiboze group, and a series of strings to match on headers (gnus-group-make-kiboze-group).

The different methods all have their peculiarities, of course.

If the gnus-activate-foreign-newsgroups is a positive number, Gnus will check all foreign groups with this level or lower at startup. This might take quite a while, especially if you subscribe to lots of groups from different NNTP servers.  It is nil by default, which means that you won't be told whether there are new articles in these groups.  How many unread articles there are will be determined when, or if, you decide to enter them.  You can also activate any group with M-g to see how many unread articles there are.

nntp
----

Subscribing to a foreign group from an NNTP server is rather easy. You just specify nntp as method and the address of the NNTP server as the, uhm, address.

If the NNTP server is located at a non-standard port, setting the third element of the select method to this port number should allow you to connect to the right port.  You'll have to edit the group info for that (see Foreign Groups).

The name of the foreign group can be the same as a native group.  In fact, you can subscribe to the same group from as many different servers you feel like.  There will be no name collisions.

The following variables can be used to create a virtual nntp server:

nntp-server-opened-hook
     nntp-server-opened-hook is run after a connection has been made. It can be used to send commands to the NNTP server after it has been contacted.  By default is sends the command MODE READER to the server with the nntp-send-mode-reader function.  Another popular function is nntp-send-authinfo, which will prompt you for an NNTP password and stuff.

nntp-maximum-request
     If the NNTP server doesn't support NOV headers, this backend will collect headers by sending a series of head commands.  To speed things up, the backend sends lots of these commands without waiting for reply, and then reads all the replies.  This is controlled by the nntp-maximum-request variable, and is 400 by default.  If your network is buggy, you should set this to 1.

nntp-connection-timeout
     If you have lots of foreign nntp groups that you connect to regularly, you're sure to have problems with NNTP servers not responding properly, or being too loaded to reply within reasonable time.  This is can lead to awkward problems, which can be helped somewhat by setting nntp-connection-timeout.  This is an integer that says how many seconds the nntp backend should wait for a connection before giving up.  If it is nil, which is the default, no timeouts are done.

nntp-server-hook
     This hook is run as the last step when connecting to an NNTP server.

nntp-open-server-function
     This function is used to connect to the remote system.  Two pre-made functions are nntp-open-network-stream, which is the default, and simply connects to some port or other on the remote system.  The other is nntp-open-rlogin, which does an rlogin on the remote system, and then does a telnet to the NNTP server available there.

nntp-rlogin-parameters
     If you use nntp-open-rlogin as the nntp-open-server-function, this list will be used as the parameter list given to rsh.

nntp-rlogin-user-name
     User name on the remote system when using the rlogin connect function.

nntp-address
     The address of the remote system running the NNTP server.

nntp-port-number
     Port number to connect to when using the nntp-open-network-stream connect function.

nntp-buggy-select
     Set this to non-nil if your select routine is buggy.

nntp-nov-is-evil
     If the NNTP server does not support NOV, you could set this variable to t, but nntp usually checks whether NOV can be used automatically.

nntp-xover-commands
     List of strings that are used as commands to fetch NOV lines from a server.  The default value of this variable is ("XOVER" "XOVERVIEW").

nntp-prepare-server-hook
     A hook run before attempting to connect to an NNTP server.

nnspool
-------

Subscribing to a foreign group from the local spool is extremely easy, and might be useful, for instance, to speed up reading groups like alt.binaries.pictures.furniture.

Anyways, you just specify nnspool as the method and "" (or anything else) as the address.

If you have access to a local spool, you should probably use that as the native select method (see Finding the News).

nnspool-inews-program
     Program used to post an article.

nnspool-inews-switches
     Parameters given to the inews program when posting an article.

nnspool-spool-directory
     Where nnspool looks for the articles.  This is normally /usr/spool/news/.

nnspool-nov-directory
     Where nnspool will look for NOV files.  This is normally /usr/spool/news/over.view/.

nnspool-lib-dir
     Where the news lib dir is (/usr/lib/news/ by default).

nnspool-active-file
     The path of the active file.

nnspool-newsgroups-file
     The path of the group description file.

nnspool-history-file
     The path of the news history file.

nnspool-active-times-file
     The path of the active date file.

nnspool-nov-is-evil
     If non-nil, nnspool won't try to use any NOV files that it finds.

nnvirtual
---------

An nnvirtual group is really nothing more than a collection of other groups.

For instance, if you are tired of reading many small group, you can put them all in one big group, and then grow tired of reading one big, unwieldy group.  The joys of computing!

You specify nnvirtual as the method.  The address should be a regexp to match component groups.

All marks in the virtual group will stick to the articles in the component groups.  So if you tick an article in a virtual group, the article will also be ticked in the component group from whence it came. (And vice versa - marks from the component groups will also be shown in the virtual group.)

Here's an example nnvirtual method that collects all Andrea Dworkin newsgroups into one, big, happy newsgroup:

     (nnvirtual "^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*")

The component groups can be native or foreign; everything should work smoothly, but if your computer explodes, it was probably my fault.

Collecting the same group from several servers might actually be a good idea if users have set the Distribution header to limit distribution. If you would like to read soc.motss both from a server in Japan and a server in Norway, you could use the following as the group regexp:

     "^nntp+some.server.jp:soc.motss$\\|^nntp+some.server.no:soc.motss$"

This should work kinda smoothly - all articles from both groups should end up in this one, and there should be no duplicates.  Threading (and the rest) will still work as usual, but there might be problems with the sequence of articles.  Sorting on date might be an option here (see Selecting a Group.

One limitation, however - all groups that are included in a virtual group has to be alive (ie. subscribed or unsubscribed).  Killed or zombie groups can't be component groups for nnvirtual groups.

nnkiboze
--------

Kibozing is defined by OED as "grepping through (parts of) the news feed".  nnkiboze is a backend that will do this for you.  Oh joy! Now you can grind any NNTP server down to a halt with useless requests!  Oh happiness!

The address field of the nnkiboze method is, as with nnvirtual, a regexp to match groups to be "included" in the nnkiboze group.  There most similarities between nnkiboze and nnvirtual ends.

In addition to this regexp detailing component groups, an nnkiboze group must have a score file to say what articles that are to be included in the group (see Score Files).

You must run M-x nnkiboze-generate-groups after creating the nnkiboze groups you want to have.  This command will take time.  Lots of time.  Oodles and oodles of time.  Gnus has to fetch the headers from all the articles in all the components groups and run them through the scoring process to determine if there are any articles in the groups that are to be part of the nnkiboze groups.

Please limit the number of component groups by using restrictive regexps.  Otherwise your sysadm may become annoyed with you, and the NNTP site may throw you off and never let you back in again. Stranger things have happened.

nnkiboze component groups do not have to be alive - they can be dead, and they can be foreign.  No restrictions.

The generation of an nnkiboze group means writing two files in nnkiboze-directory, which is ~/News/ by default.  One contains the NOV header lines for all the articles in the group, and the other is an additional .newsrc file to store information on what groups that have been searched through to find component articles.

Articles that are marked as read in the nnkiboze group will have their NOV lines removed from the NOV file.

nndir
-----

If you have a directory that has lots of articles in separate files in it, you might treat it as a newsgroup.  The files have to have numerical names, of course.

This might be an opportune moment to mention ange-ftp, that most wonderful of all wonderful Emacs packages.  When I wrote nndir, I didn't think much about it - a backend to read directories.  Big deal.

ange-ftp changes that picture dramatically.  For instance, if you enter "/ftp@sina.tcamc.uh.edu:/pub/emacs/ding-list/" as the the directory name, ange-ftp will actually allow you to read this directory over at sina as a newsgroup.  Distributed news ahoy!

nndir will use NOV files if they are present.

nndoc
-----

nndoc is a cute little thing that will let you read a single file as a newsgroup.  The file has to be divided into articles by the use of Unix mbox From  lines.  nndoc will not try to change the file or insert any extra headers into it - it will simply, like, let you use the file as the basis for a group.  And that's it.

nndigest
--------

nndigest is a bit odd.  It will use a buffer containing a valid digest as the basis for a group.

These nndigest groups are rather ephemeral.  They will never store information on what articles you have read, and you can't really use them as foreign groups at all.  The only way to reach an nndigest group is to type V D on a digest in the summary buffer.

When you have finished reading the digest and press q, you will be returned to the group from whence you came instead of going to the group buffer.

Odd all over, as you can see, but somewhat useful.

Reading Mail
------------

Reading mail with a newsreader - isn't that just plain WeIrD? But of course.

Gnus will read the mail spool when you activate a mail group.  The mail file is first copied to your home directory.  What happens after that depends on what format you want to store your mail in.

The mail backends all call nnmail-read-incoming-hook after reading new mail.  You can use this hook to notify any mail watch programs, if you want to.

nnmail-spool-file says where to look for new mail.  If this variable is nil, the mail backends will never attempt to fetch mail by themselves.  It is quite likely that Gnus supports POP-mail. Set this variable to begin with the string po:, and everything should go smoothly, even though I have never tested this.

nnmail-prepare-incoming-hook is run in a buffer that holds all the new incoming mail, and can be used for, well, anything, really.

nnmail-tmp-directory says where to move the incoming mail to while processing it.  This is usually done in the same directory that the mail backend habitates (ie. ~/Mail/), but if this variable is non-nil, it will be used instead.

Gnus gives you all the opportunity you could possibly want for shooting yourself in the foot.  Let's say you create a group that will contain all the mail you get from your boss.  And then you accidentally unsubscribe from the group.  Gnus will still put all the mail from your boss in the unsubscribed group, and so, when your boss mails you "Have that report ready by Monday or you're fired!", you'll never see it and, come Tuesday, you'll still believe that you're gainfully employed while you really should be out collecting empty bottles to save up for next month's rent money.

Creating Mail Groups
....................

You can make Gnus read your personal, private, secret mail.

You should first set gnus-secondary-select-methods to, for instance, ((nnmbox "")).  When you start up Gnus, Gnus will ask this backend for what groups it carries (mail.misc by default) and subscribe it the normal way.  (Which means you may have to look for it among the zombie groups, I guess, all depending on your gnus-subscribe-newsgroup-method variable.)

Then you should set the variable nnmail-split-methods to specify how the incoming mail is to be split into groups.

     (setq nnmail-split-methods
       '(("mail.junk" "^From:.*Lars Ingebrigtsen")
         ("mail.crazzy" "^Subject:.*die\\|^Organization:.*flabby")
         ("mail.other" "")))

This variable is a list of lists, where the first element of each of these lists is the name of the mail group (they do not have to be called something beginning with mail, by the way), and the second element is a regular expression used on the header of each mail to determine if it belongs in this mail group.

The second element can also be a function.  In that case, it will be called narrowed to the headers with the first element of the rule as the argument.  It should return a non-nil value if it thinks that the mail belongs in that group.

The last of these groups should always be a general one, and the regular expression should always be "" so that it matches any mails that haven't been matched by any of the other regexps.

If you like to tinker with this yourself, you can set this variable to a function of your choice. This function will be called without any arguments in a buffer narrowed to the headers of an incoming mail message. The function should return a list of groups names that it thinks should carry this mail message.

The mail backends all support cross-posting.  If several regexps match, the mail will be "cross-posted" to all those groups. nnmail-crosspost says whether to use this mechanism or not.

Mail & Procmail
...............

Many people use procmail to split incoming mail into groups.  If you do that, you should set nnmail-spool-file to nil to make sure that the mail backends never ever try to fetch mail by themselves.

This also means that you probably don't want to set nnmail-split-methods either, which has some, perhaps, unexpected side effects.

When a mail backend is queried for what groups it carries, it replies with the contents of that variable, along with any groups it has figured out that it carries by other means.  None of the backends (except nnmh) actually go out to the disk and check what groups actually exist.  (It's not trivial to distinguish between what the user thinks is a basis for a newsgroup and what is just a plain old file or directory.)

This means that you have to tell Gnus (and the backends) what groups exist by hand.

Let's take the nnfolder backend as an example.  (This backend uses one file as the basis of each group.)

The folders are located in nnfolder-directory, say, ~/Mail/.  There are three folders, foo, bar and mail.baz.

Go to the group buffer and type M m.  When prompted, answer foo for the name and nnfolder for the method.  Repeat twice for the two other groups, bar and mail.baz.  Be sure to include all your mail groups.

That's it.  You are now set to read your mail.  An active file for this method will be created automatically.

Expiring Old Mail Articles
..........................

Traditional mail readers have a tendency to remove mail articles when you mark them as read, in some way.  Gnus takes a fundamentally different approach to mail reading.

Gnus basically considers mail just to be news that has been received in a rather peculiar manner.  It does not think that it has the power to actually change the mail, or delete any mail messages.  If you enter a mail group, and mark articles as "read", or kill them in some other fashion, the mail articles will still exist on the system.  I repeat: Gnus will not delete your old, read mail.  Unless you ask it to, of course.

To make Gnus get rid of your unwanted mail, you have to mark the articles as expirable.  This does not mean that the articles will disappear right away, however.  In general, a mail article will be deleted from your system if, 1) it is marked as expirable, AND 2) it is more than one week old.  If you do not mark an article as expirable, it will remain on your system until hell freezes over.  This bears repeating one more time, with some spurious capitalizations: IF you do NOT mark articles as EXPIRABLE, Gnus will NEVER delete those ARTICLES.

You do not have to mark articles as expirable by hand.  Groups that match the regular expression gnus-auto-expirable-newsgroups will have all articles that you read marked as expirable automatically.  All articles that are marked as expirable have an E in the first column in the summary buffer.

Let's say you subscribe to a couple of mailing lists, and you want the articles you have read to disappear after a while:

     (setq gnus-auto-expirable-newsgroups
           "mail.nonsense-list\\|mail.nice-list")

Another way to have auto-expiry happen is to have the element auto-expire in the select method of the group.

The nnmail-expiry-wait variable supplies the default time an expirable article has to live.  The default is seven days.

Gnus also supplies a function that lets you fine-tune how long articles are to live, based on what group they are in.  Let's say you want to have one month expiry period in the mail.private group, a one day expiry period in the mail.junk group, and a six day expiry period everywhere else:

     (setq nnmail-expiry-wait-function
           (lambda (group)
            (cond ((string= group "mail.private")
                    31)
                  ((string= group "mail.junk")
                    1)
                  (t
                    6))))

If nnmail-keep-last-article is non-nil, Gnus will never expire the final article in a mail newsgroup.  This is to make life easier for procmail users.

Not Reading Mail
................

If you start using any of the mail backends, they have the annoying habit of assuming that you want to read mail with them.  This might not be unreasonable, but it might not be what you want.

If you set nnmail-spool-file to nil, none of the backends will ever attempt to read incoming mail, which should help.

This might be too much, if, for instance, you are reading mail quite happily with nnml and just want to peek at some old RMAIL file you have stashed away with nnbabyl.  All backends have variables called backend-get-new-mail.  If you want to disable the nnbabyl mail reading, you just set nnbabyl-get-new-mail to nil.

nnmbox
......

The nnmbox backend will use the standard Un*x mbox file to store mail.  nnmbox will add extra headers to each mail article to say which group it belongs in.

nnmbox-mbox-file
     The name of the mail box in the user's home directory.

nnmbox-active-file
     The name of the active file for the mail box.

nnmbox-get-new-mail
     If non-nil, nnmbox will read incoming mail and split it into groups.

nnbabyl
.......

The nnbabyl backend will use a babyl mail box to store mail. nnbabyl will add extra headers to each mail article to say which group it belongs in.

nnbabyl-mbox-file
     The name of the rmail mbox file.

nnbabyl-active-file
     The name of the active file for the rmail box.

nnbabyl-get-new-mail
     If non-nil, nnbabyl will read incoming mail.

nnml
....

The nnml spool mail format isn't compatible with any other known format.  It should be used with some caution.

If you use this backend, Gnus will split all incoming mail into files; one file for each mail, and put the articles into the correct directories under the directory specified by the nnml-directory variable.  The default value is ~/Mail/.

You do not have to create any directories beforehand; Gnus will take care of all that.

If you have a strict limit as to how many files you are allowed to store in your account, you should not use this backend.  As each mail gets its own file, you might very well occupy thousands of inodes within a few weeks.  If this is no problem for you, and it isn't a problem for you having your friendly systems administrator walking around, madly, shouting "Who is eating all my inodes?! Who? Who!?!", then you should know that this is probably the fastest format to use.  You do not have to trudge through a big mbox file just to read your new mail.

nnml is probably the slowest backend when it comes to article splitting.  It has to create lots of files, and it also generates NOV databases for the incoming mails.  This makes is the fastest backend when it comes to reading mail.

nnml-directory
     All nnml directories will be placed under this directory.

nnml-active-file
     The active file for the nnml server.

nnml-newsgroups-file
     The nnml group description file.

nnml-get-new-mail
     If non-nil, nnml will read incoming mail.

nnml-nov-is-evil
     If non-nil, this backend will ignore any NOV files.

nnml-nov-file-name
     The name of the NOV files.  The default is .overview.

If your nnml groups and NOV files get totally out of whack, you can do a complete update by typing M-x nnml-generate-nov-databases.  This command will trawl through the entire nnml hierarchy, looking at each and every article, so it might take a while to complete.

nnmh
....

nnmh is just like nnml, except that is doesn't generate NOV databases and it doesn't keep an active file.  This makes nnmh a much slower backend than nnml, but it also makes it easier to write procmail scripts for.

nnml-directory
     All nnmh directories will be located under this directory.

nnmh-get-new-mail
     If non-nil, nnml will read incoming mail.

nnfolder
........

nnfolder is a backend for storing each mail group in a separate file.  Each file is in the standard Un*x mbox format.  nnfolder will add extra headers to keep track of article numbers and arrival dates.

nnfolder-directory
     All the nnfolder mail boxes will be stored under this directory.

nnfolder-active-file
     The name of the active file.

nnfolder-newsgroups-file
     The name of the group description file.

nnfolder-get-new-mail
     If non-nil, nnfolder will read incoming mail.

Group Parameters
================

Gnus stores all information on a group in a list that is usually known as the group info.  This list has from three to six elements. Here's an example info.

     ("nnml:mail.ding" 3 ((1 . 232) 244 (256 . 270)) ((tick 246 249))
                       (nnml "private") ((to-address . "ding@ifi.uio.no")))

The first element is the group name, as Gnus knows the group, anyway.  The second element is the subscription level, which normally is a small integer.  The third element is a list of ranges of read articles.  The fourth element is a list of lists of article marks of various kinds.  The fifth element is the select method (or virtual server, if you like).  The sixth element is a list of group parameters, which is what this section is about.

Any of the last three elements may be missing if they are not required. In fact, the vast majority of groups will normally only have the first three elements, which saves quite a lot of cons cells.

At present, there's not much you can put in the group parameters list:

to-address
     If the group parameter list contains an element that looks like (to-address .  "some@where.com"), that address will be used by the backend when doing followups and posts.  This is primarily useful in mail groups that represent mailing lists.  You just set this address to whatever the list address is.

     This trick will actually work whether the group is foreign or not. Let's say there's a group on the server that is called fa.4ad-l. This is a real newsgroup, but the server has gotten the articles from a mail-to-news gateway.  Posting directly to this group is therefore impossible - you have to send mail to the mailing list address instead.

auto-expire
     If this symbol is present in the group parameter list, all articles that are read will be marked as expirable.  For an alternative approach, see Expiring Old Mail Articles.

If you want to change the group parameters (or anything else of the group info) you can use the M E to edit enter a buffer where you can edit the group info.

You usually don't want to edit the entire group info, so you'd be better off using the M p command to just edit the group parameters.

Listing Groups
==============

These commands all list various slices of the groups that are available.

l
G s
     List all groups that have unread articles (gnus-group-list-groups).  If the numeric prefix is used, this command will list only groups of level ARG and lower.  By default, it only lists groups of level five or lower (ie. just subscribed groups).

L
G u
     List all groups, whether they have unread articles or not (gnus-group-list-all-groups).  If the numeric prefix is used, this command will list only groups of level ARG and lower.  By default, it lists groups of level seven or lower (ie. just subscribed and unsubscribed groups).

G k
     List all killed groups (gnus-group-list-killed).

G z
     List all zombie groups (gnus-group-list-zombies).

G m
     List all subscribed groups with unread articles that match a regexp (gnus-group-list-matching).

G M
     List groups that match a regexp (gnus-group-list-all-matching).

Group Maintenance
=================

b
     Find bogus groups and delete them (gnus-group-check-bogus-groups).

F
     Find new groups and process them (gnus-find-new-newsgroups).

C-c C-x
     Run all expirable articles in the current group through the expiry process (if any) (gnus-group-expire-articles).

C-c M-C-x
     Run all articles in all groups through the expiry process (gnus-group-expire-all-groups).

C-c C-s
     Sort the groups according to the function given by the gnus-group-sort-function variable (gnus-group-sort-groups).  Available sorting functions include gnus-group-sort-by-alphabet (the default), gnus-group-sort-by-unread and gnus-group-sort-by-level.

Browse Foreign Server
=====================

B
     You will be queried for a select method and a server name.  Gnus will then attempt to contact this server and let you browse the groups there (gnus-group-browse-foreign-server).

A new buffer with a list of available groups will appear.  This buffer will be use the gnus-browse-server-mode.  This buffer looks a bit (well, a lot) like a normal group buffer, but with one major difference - you can't enter any of the groups.  If you want to read any of the news available on that server, you have to subscribe to the groups you think may be interesting, and then you have to exit this buffer.  The new groups will be added to the group buffer, and then you can read them as you would any other group.

Future versions of Gnus may possibly permit reading groups straight from the browse buffer.

Here's a list of keystrokes available in the browse mode:

n
     Go to the next group (gnus-group-next-group).

p
     Go to the previous group (gnus-group-prev-group).

u
     Unsubscribe to the current group, or, as will be the case here, subscribe to it (gnus-browse-unsubscribe-current-group).

l
q
     Exit browse mode (gnus-browse-exit).

?
     Describe browse mode briefly (well, there's not much to describe, is there) (gnus-browse-describe-briefly).

Exiting Gnus
============

Yes, Gnus is ex(c)iting.

z
     Suspend Gnus (gnus-group-suspend).  This doesn't really exit Gnus, but it kills all buffers exept the Group buffer.  I'm not sure why this is a gain, but then who am I to judge?

q
     Quit Gnus (gnus-group-exit).

Q
     Quit Gnus without saving any startup files (gnus-group-quit).

gnus-suspend-gnus-hook is called when you suspend Gnus and gnus-exit-gnus-hook is called when you quit Gnus.

Note:

     Miss Lisa Cannifax, while sitting in English class, feels her feet go numbly heavy and herself fall into a hazy trance as the boy sitting behind her drew repeated lines with his pencil across the back of her plastic chair.

Misc Group Stuff
================

g
     Check server for new articles. If the numeric prefix is used, this command will check only groups of level ARG and lower (gnus-group-get-new-news).

M-g
     Check whether new articles have arrived in the current group (gnus-group-get-new-news-this-group).

^
     Enter the server buffer (gnus-group-enter-server-mode). See The Server Buffer.

M-f
     Try to fetch the FAQ for the current group (gnus-group-fetch-faq).  Gnus will try to get the FAQ from gnus-group-faq-directory, which is usually a directory on a remote machine. ange-ftp will be used for fetching the file.

R
     Restart Gnus (gnus-group-restart).

r
     Read the init file (gnus-init-file, which defaults to ~/.gnus) (gnus-group-read-init-file).

s
     Save the .newsrc.eld file (and .newsrc if wanted) (gnus-group-save-newsrc).

Z
     Clear the dribble buffer (gnus-group-clear-dribble).

D
     Describe the current group (gnus-group-describe-group).  If given a prefix, force Gnus to re-read the description from the server.

G a
     List all groups that have names that match a regexp (gnus-group-apropos).

G d
     List all groups that have names or descriptions that match a regexp (gnus-group-description-apropos).

a
     Post an article to a group (gnus-group-post-news).

m
     Mail a message somewhere (gnus-group-mail).

C-x C-t
     Transpose two groups (gnus-group-transpose-groups).

V
     Display current Gnus version numbers (gnus-version).

M-d
     Describe all groups (gnus-group-describe-all-groups).  If given a prefix, force Gnus to re-read the descriptoion file from the server.

?
     Give a very short help message (gnus-group-describe-briefly).

C-c C-i
     Go to the Gnus info node (gnus-info-find-node).

gnus-group-prepare-hook is called after the group buffer is generated.  It may be used to modify the buffer in some strange, unnatural way.

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
=====================

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.

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.

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 address (from the From header).

L
     Number of lines in the article.

c
     Number of characters in the article.

I
     Indentation based on thread level (see 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 bracked, 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.

x
     Xref.

D
     Date.

M
     Message-Id.

r
     References.

t
     Number of articles in the current subthread.  Using this spec will slow down summary buffer generation somewhat.

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.

Text between %( and %) will be highlighted with gnus-mouse-face when the mouse point is placed inside the area. There can only be one such area.

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.

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 anread 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.

Summary Manouvering
===================

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 g
j
     Ask for an article number and then go to this summary line (gnus-summary-goto-subject).

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 gnus-auto-select-next 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.  Also see Group Levels.

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.

If gnus-auto-center-summary is 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.

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.

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-visual-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-visual-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.

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
     Scoll the current article back one page (gnus-summary-prev-page).

RET
     Scroll the current article one line forward (gnus-summary-scroll-up).

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).

Reply, Followup and Post
========================

All the commands for posting and mailing will put you in a post or mail buffer where you can edit the article all you like, before you send the article by pressing C-c C-c.  If you are in a foreign news group, and you wish to post the article using the foreign server, you can give a prefix to C-c C-c to make Gnus try to post using the foreign server.

Mail
----

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).

S C-f
     Forward the current article to some other person (gnus-summary-mail-forward).

S m
m
     Send a mail to some other person (gnus-summary-mail-other-window).

S M-f
     Digest the current series and forward the result using mail (gnus-uu-digest-and-forward).  This command uses the process/prefix convention (see Process/Prefix).

Variables for customizing outgoing mail:

gnus-reply-to-function
     Gnus uses the normal methods to determine where replies are to go, but you can change the behaviour to suit your needs by fiddling with this variable.

     If you want the replies to go to the Sender instead of the From in the group mail.stupid-list, you could do something like this:

          (setq gnus-reply-to-function
                (lambda (group)
                 (cond ((string= group "mail.stupid-list")
                         (mail-fetch-field "sender"))
                       (t
                        nil))))

     This function will be called narrowed to the head of the article that is being replied to.

     As you can see, this function should return a string if it has an opinion as to what the To header should be.  If it does not, it should just return nil, and the normal methods for determining the To header will be used.

     This function can also return a list.  In that case, each list element should be a cons, where the car should be the name of an header (eg. Cc) and the cdr should be the header value (eg. larsi@ifi.uio.no).  All these headers will be inserted into the head of the outgoing mail.

gnus-mail-send-method
     This variable says how a mail should be mailed.  It uses the function in the send-mail-function variable as the default.

Post
----

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).

S u
     Uuencode a file, split it into parts, and post it as a series (gnus-uu-post-news) (see Uuencoding & Posting).

gnus-required-headers a list of header symbols.  These headers will either be automatically generated, or, if that's impossible, they will be prompted for.  The following symbols are legal:

From
     This required header will be filled out with the result of the gnus-inews-user-name function, which depends on the gnus-user-from-line, gnus-user-login-name, gnus-local-domain and user-mail-address variables.

Subject
     This required header will be prompted for if not present already.

Newsgroups
     This required header says which newsgroups the article is to be posted to.  If it isn't present already, it will be prompted for.

Organization
     This optional header will be filled out depending on the gnus-local-organization variable.

Lines
     This optional header will be computed by Gnus.

Message-ID
     This required header will be generated by Gnus.  A unique ID will be created based on date, time, user name and system name.

X-Newsreader
     This optional header will be filled out with the Gnus version numbers.

In addition, you can enter conses into this list.  The car of this cons should be a symbol who's name is the name of the header, and the cdr can either a string to be entered verbatim as the value of this header, or it can be a function to be called.  This function should return a string to be inserted.  For instance, if you want to insert Mime-Version: 1.0, you should enter (Mime-Version . "1.0") into the list.  If you want to insert a funny quote, you could enter something like (X-Yow . yow) into the list.  The function yow will then be called without any arguments.

Other variables for customizing outgoing articles:

gnus-post-method
     If non-nil, Gnus will use this method instead of the default select method when posting.

nntp-news-default-headers
     If non-nil, this variable will override mail-default-headers when posting.  This variable should then be a string.  This string will be inserted, as is, in the head of all outgoing articles.

gnus-use-followup-to
     If nil, always ignore the Followup-To header.  If it is t, use its value, but ignore the special value poster, which will send the followup as a reply mail to the person you are responding to. If it is neither nil nor t, always use the Followup-To value.

gnus-followup-to-function
     This variable is most useful in mail groups, where "following up" really means sending a mail to a list address.  Gnus uses the normal methods to determine where follow-ups are to go, but you can change the behaviour to suit your needs by fiddling with this variable.

     If you want the followups to go to the Sender instead of the From in the group mail.stupid-list, you could do something like this:

          (setq gnus-followup-to-function
                (lambda (group)
                 (cond ((string= group "mail.stupid-list")
                         (mail-fetch-field "sender"))
                       (t
                        nil))))

     This function will be called narrowed to header of the article that is being followed up.

gnus-signature-function
     If non-nil, this variable should be a function that returns a signature file name.  The function will be called with the name of the group being posted to.  If the function returns a string that doesn't correspond to a file, the string itself is inserted.  If the function returns nil, the gnus-signature-file variable will be used instead.

gnus-post-prepare-function
     This function is called with the name of the current group after the post buffer has been initialized, and can be used for inserting a signature.  Nice if you use different signatures in different groups.

news-reply-header-hook
     A related variable when following up and replying is this variable, which inserts the quote line.  The default value is:

          (defvar news-reply-header-hook
            (lambda ()
              (insert "In article " news-reply-yank-message-id
                      " " news-reply-yank-from " writes:\n\n")))

     This will create lines like:

          In article <zngay8jrql@eyesore.no> Lars Mars <lars@eyesore.no> writes:

     Having the Message-Id in this line is probably overkill, so I would suggest this hook instead:

          (setq news-reply-header-hook
            (lambda () (insert news-reply-yank-from " writes:\n\n")))

gnus-prepare-article-hook
     This hook is called before the headers have been prepared.  By default it inserts the signature specified by gnus-signature-file.

gnus-inews-article-hook
     This hook is called right before the article is posted.  By default it handles FCC processing (ie. saving the article to a file.)

gnus-inews-article-header-hook
     This hook is called after inserting the required headers in an article to be posted.  The hook is called from the *post-news* buffer, narrowed to the head, and is intended for people who would like to insert additional headers, or just change headers in some way or other.

gnus-check-before-posting
     If non-nil, Gnus will attempt to check the legality of the headers, as well as some other stuff, before posting.

Mail & Post
-----------

Commands for sending mail and post at the same time:

S b
     Post a followup and send a reply to the current article (gnus-summary-followup-and-reply).

S B
     Post a followup and send a reply to the current article and include the original message (gnus-summary-followup-and-reply-with-original).

Here's a list of variables that are relevant to both mailing and posting:

gnus-signature-file
mail-signature
     If gnus-signature-file is non-nil, it should be the name of a file containing a signature (~/.signature by default).  This signature will be appended to all outgoing post.  Most people find it more convenient to use mail-signature, which does the same, but inserts the signature into the buffer before you start editing the post (or mail).  So - if you have both of these variables set, you will get two signatures.

     Note that RFC1036 says that a signature should be preceded by the three characters --  on a line by themselves.  This is to make it easier for the recipient to automatically recognize and process the signature.  So don't remove those characters, even though you might feel that they ruin you beautiful design, like, totally.

     Also note that no signature should be more than four lines long. Including ASCII graphics is an efficient way to get everybody to believe that you are silly and have nothing important to say.

mail-yank-prefix
     When you are replying to or following up an article, you normally want to quote the person you are answering.  Inserting quoted text is done by yanking, and each quoted line you yank will have mail-yank-prefix prepended to it.  This is   by default, which isn't very pretty.  Most everybody prefers that lines are prepended with > , so (setq mail-yank-prefix "> ") in your .emacs file.

mail-yank-ignored-headers
     When you yank a message, you do not want to quote any headers, so (setq mail-yank-ignored-headers ":").

user-mail-address
     If all of gnus-user-login-name, gnus-use-generic-from and gnus-local-domain are nil, Gnus will use user-mail-address as the address part of the From header.

gnus-user-from-line
     Your full, complete e-mail address.  This variable overrides the other Gnus variables if it is non-nil.

     Here are two example values of this variable: "larsi@ifi.uio.no (Lars Magne Ingebrigtsen)" and "Lars Magne Ingebrigtsen <larsi@ifi.uio.no>". The latter version is recommended, but the name has to be quoted if it contains non-alphanumerical characters - "\"Lars M. Ingebrigtsen\" <larsi@ifi.uio.no>".

mail-default-headers
     This is a string that will be inserted into the header of all outgoing mail messages and news articles.  Convenient to use to insert standard headers.  If nntp-news-default-headers is non-nil, that variable will override this one when posting articles.

gnus-auto-mail-to-author
     If ask, you will be prompted for whether you want to send a mail copy to the author of the article you are following up.  If non-nil and not ask, Gnus will send a mail with a copy of all follow-ups to the authors of the articles you follow up.  It's nice in one way - you make sure that the person you are responding to gets your response.  Other people loathe this method and will hate you dearly for it, because it means that they will first get a mail, and then have to read the same article later when they read the news.  It is nil by default.

gnus-mail-courtesy-message
     This is a string that will be prepended to all mails that are the result of using the variable described above.

Cancelling 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 cancelled - 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 cancelling, 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 cancelled/superseded.

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

Ticking and Marking
===================

There are several marks you can set on an article.

You have marks that decide the readed-ness (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.

There's a plethora of commands for manipulating these marks:

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.

SPC
     An unread article is marked with a SPC (gnus-unread-mark).  These are articles that haven't been read at all yet.

Read Articles
-------------

All the following marks mark articles as read.

D
     Articles that are marked as read.  They have a D (gnus-dread-mark) in the first column.  These are articles that the user has marked as read more or less manually.

d
     Articles that are actually read are marked with d (gnus-read-mark).

A
     Articles that were marked as read in previous sessions are now ancient and marked with A (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
     Cancelled article (gnus-cancelled-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 cat's 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 will be marked with an R in the second column (gnus-replied-mark).

Finally we have the 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.

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
     Catchup the current group (gnus-summary-catchup).

M C-c
     Catchup all articles in the current group (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 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 M-r
x
     Expunge all deleted articles from the summary buffer (gnus-summary-remove-lines-marked-as-read).

M M-C-r
     Ask for a mark and then expunge all articles that have been marked with that mark (gnus-summary-remove-lines-marked-with).

M S
     Display all expunged articles (gnus-summary-show-all-expunged).

M D
     Display all dormant articles (gnus-summary-show-all-dormant).

M M-D
     Hide all dormant articles (gnus-summary-hide-all-dormant).

M s k
     Kill all articles with scores below the default score (or below the numeric prefix) (gnus-summary-kill-below).

M s c
     Clear all marks from articles with scores over the default score (or over the numeric prefix) (gnus-summary-clear-above).

M s u
     Tick all articles with scores over the default score (or over the numeric prefix) (gnus-summary-tick-above).

M s 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).

gnus-summary-goto-unread 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.

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 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).

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
---------------------

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.  In either case, fetching old headers only works if the select method you are using supports XOVER.  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-gather-loose-threads
     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.

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 real 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-summary-make-false-root
     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.

     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 Summary Buffer Format).)

     nil
          Don't make any article parent at all.  Just gather the threads and display them after one another.

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 subthread should be indented. The default is 4.

Thread Commands
---------------

T k
M-C-k
     Mark all articles in the current subtread 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 #
     Mark the current thread with the process mark (gnus-uu-mark-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).

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).

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).

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).

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

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, 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.

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.

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

C'est la vie.

Process/Prefix
==============

Many functions, among them functions for moving, decoding and saving articles, use what is known as the Process/Prefix convention.

This is a method for figuring out what articles that the user wants the command to be performed on.

It goes like this:

If the numeric prefix is N, perform the operation on the next N articles, starting with the current one.  If the numeric prefix is negative, perform the operation on the previous N articles, starting with the current one.

If there is no numeric prefix, but some articles are marked with the process mark, perform the operation on the articles that are marked with the process mark.

If there is neither a numeric prefix nor any articles marked with the process mark, just perform the operation on the current article.

Quite simple, really, but it needs to be made clear so that surprises are avoided.

Saving Articles
===============

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

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

V o o
o
     Save the current article using the default article saver (gnus-summary-save-article).

V o m
     Save the current article in mail format (gnus-summary-save-article-mail).

V o r
     Save the current article in rmail format (gnus-summary-save-article-rmail).

V o f
     Save the current article in plain file format (gnus-summary-save-article-file).

V o h
     Save the current article in mh folder format (gnus-summary-save-article-folder).

V 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 Process/Prefix).

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-in-folder
     Save the article to an MH folder using rcvstore from the MH library.

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.

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.

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 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.

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.

All these functions use the process/prefix convention (see 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 uncode 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 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
..............

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-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 kludgy.

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 dispay.

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 & 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 detar 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.

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

Various Article Stuff
=====================

A w
     Remove page breaks from the current article (gnus-summary-stop-page-breaking).

A s
     Perform an isearch in the article buffer (gnus-summary-isearch-article).

A c
     Do a Caesar rotate (rot13) on the article buffer (gnus-summary-caesar-message).

A g
     Select the current article (gnus-summary-show-article).

A t
     Toggle whether to display all headers in the article buffer (gnus-summary-toggle-header).

A m
     Toggle whether to run the article through MIME before displaying (gnus-summary-toggle-mime).

There's a battery of commands for washing the article buffer:

A h h
     Hide headers (gnus-article-hide-headers).

A h s
     Hide signature (gnus-article-hide-signature).

A h c
     Hide citation (gnus-article-hide-citation).

A h o
     Treat overstrike (gnus-article-treat-overstrike).

A h w
     Do word wrap (gnus-article-word-wrap).

A h d
     Remove CR (gnus-article-remove-cr).

A h q
     Treat quoted-printable (gnus-article-de-quoted-unreadable).

A h 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.

Summary Sorting
===============

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

V s n
     Sort by article number (gnus-summary-sort-by-number).

V s a
     Sort by author (gnus-summary-sort-by-author).

V s s
     Sort by subject (gnus-summary-sort-by-subject).

V s d
     Sort by date (gnus-summary-sort-by-date).

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 Thread Commands).

Finding the Parent
==================

If you'd like to read the parent of the current article, and it is not displayed in the article 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 also ask the NNTP server for an arbitrary article, no matter what group it belongs to.  V r (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.

Score Files
===========

Other people use kill files, but we here at (ding) Gnus Towers like scoring better than killing, so we'd rather switch than fight.  They do something completely different as well, so sit up straight and pay attention!

All articles have a default score (gnus-summary-default-score). This score may be raised or lowered either interactively or by score files.  Articles that have a score lower than gnus-summary-mark-below are marked as read.

Gnus will read any score files that apply to the current group before generating the summary buffer.

There are several commands in the summary buffer that inserts score entries based on the current article.  You can, for instance, ask Gnus to lower or increase the score of all articles with a certain subject.

There are two sorts of scoring entries: Permanent and temporary. Temporary score entries are self-expiring entries.  Any entries that are temporary and have not been used for, say, a week, will be removed silently to help keep the sizes of the score files down.

Summary Score Commands
----------------------

The score commands that alter score entries do not actually modify real score files.  That would be too inefficient.  Gnus maintains a cache of previously loaded score files, one of which is considered the current score file alist.  The score commands simply insert entries into this list, and upon group exit, this list is saved.

The current score file is by default the group's local score file, even if no such score file actually exists.  To insert score commands into some other score file (eg. all.SCORE), you must first make this score file the current one.

General score commands that don't actually change the score file:

V S s
     Set the score of the current article (gnus-summary-set-score).

V S c
     Make a different score file the current (gnus-score-change-score-file).

V S e
     Edit the current score file (gnus-score-edit-alist).  You will be popped into a gnus-score-mode buffer (see Score File Editing).

V S f
     Edit a score file and make this score file the current one (gnus-score-edit-file).

I C-i
     Increase the score of the current article (gnus-summary-raise-score).

L C-l
     Lower the score of the current article (gnus-summary-lower-score).

The rest of these commands modify the local score file.

V S m
     Prompt for a score, and mark all articles with a score below this as read (gnus-score-set-mark-below).

V S E
     Expunge all articles with a score below the default score (or the numeric prefix) (gnus-score-set-expunge-below).

Commands for increasing the score:

I s t
     Increase the current subject temporarily (gnus-summary-temporarily-raise-by-subject).

I s p
     Increase the current subject permanently (gnus-summary-raise-by-subject).

I a t
     Increase the current author temporarily (gnus-summary-temporarily-raise-by-author).

I a p
     Increase the current author permanently (gnus-summary-raise-by-author).

I b t
     Increase based on a match on the body of an article temporarily (gnus-summary-temporarily-raise-by-body).  This is a very slow operation.

I b p
     Increase based on a match on the body of an article (gnus-summary-raise-by-body). This is a very slow operation

I i t
     Increase the current message-id temporarily (gnus-summary-temporarily-raise-by-id).

I i p
     Increase the current message-id permanently (gnus-summary-raise-by-id).

I t t
     Increase the current thread temporarily (gnus-summary-temporarily-raise-by-thread).

I t p
     Increase the current thread permanently (gnus-summary-raise-by-thread).

I x t
     Increase the current xref temporarily (gnus-summary-temporarily-raise-by-xref).

I x p
     Increase the current xref permanently (gnus-summary-raise-by-xref).

I f t
     Increase followups to the current author temporarily (gnus-summary-temporarily-raise-followups-to-author).

I f p
     Increase followups to the current author permanently (gnus-summary-raise-followups-to-author).

Commands for lowering the score:

L s t
     Lower the current subject temporarily (gnus-summary-temporarily-lower-by-subject).

L s p
     Lower the current subject permanently (gnus-summary-lower-by-subject).

L a t
     Lower the current author temporarily (gnus-summary-temporarily-lower-by-author).

L a p
     Lower the current author permanently (gnus-summary-lower-by-author).

L b t
     Lower based on a match on the article body (gnus-summary-temporarily-lower-by-body).  This is a very slow operation.

L b p
     Lower based on a match on the article body (gnus-summary-lower-by-body).  This is a very slow operation.

L i t
     Lower the current message-id temporarily (gnus-summary-temporarily-lower-by-id).

L i p
     Lower the current message-id permanently (gnus-summary-lower-by-id).

L t t
     Lower the current thread temporarily (gnus-summary-temporarily-lower-by-thread).

L t p
     Lower the current thread permanently (gnus-summary-lower-by-thread).

L x t
     Lower the current xref temporarily (gnus-summary-temporarily-lower-by-xref).

L x p
     Lower the current xref permanently (gnus-summary-lower-by-xref).

L f t
     Lower followups to the current author temporarily (gnus-summary-temporarily-lower-followups-to-author).

L f p
     Lower followups to the current author permanently (gnus-summary-lower-followups-to-author).

Score Variables
---------------

gnus-kill-killed
     If this variable is nil, Gnus will never apply score files to articles that have already been through the kill process.  While this may save you lots of time, it also means that if you apply a kill file to a group, and then change the kill file and want to run it over you group again to kill more articles, it won't work.  You have to set this variable to t to do that.

gnus-kill-files-directory
     All kill and score files will be stored in this directory, which is initialized from the SAVEDIR environment variable by default.

gnus-score-file-suffix
     Suffix to add to the group name to arrive at the score file name (SCORE by default.)

gnus-score-interactive-default-score
     Score used by all the interactive raise/lower commands to raise/lower score with.  Default is 1000, which may seem excessive, but this is to ensure that the adaptive scoring scheme gets enough room to play with. We don't want the small changes from the adaptive scoring to overwrite manually entered data.

gnus-summary-default-score
     Default score of an article, which is 0 by default.

gnus-score-over-mark
     Mark (in the third column) used for articles with a score over the default.  Default is +.

gnus-score-below-mark
     Mark (in the third column) used for articles with a score below the default.  Default is -.

gnus-score-find-score-files-function
     Function used to find score files for the current group.  This function is called with the name of the group as the argument.

     Predefined functions available are:

     gnus-score-find-single
          Only apply the group's own score file.

     gnus-score-find-bnews
          Apply all score files that match, using bnews syntax.  For instance, if the current group is gnu.emacs.gnus, all.emacs.all.SCORE, not.alt.all.SCORE and gnu.all.SCORE would all apply.  In short, the instances of all in the score file names are translated into .*, and then a regexp match is done.

     gnus-score-find-hierarchical
          Apply all score files from all the parent groups.

     This variable can also be a list of functions.  In that case, all these functions will be called, and all the returned lists of score files will be applied.  These functions can also return lists of score alists directly.  In that case, the functions that return these non-file score alists should probably be placed before the "real" score file functions, to ensure that the last score file returned is the local score file. Phu.

gnus-kill-expiry-days
     This variable says how many days should pass before an unused score file entry is expired.  The default is 7.

Score File Format
-----------------

A score file is an emacs-lisp file that normally contains just a single form.  Casual users are not expected to edit these files; everything can be changed from the summary buffer.

Anyway, if you'd like to dig into it yourself, here's an example:

     (("from"
       ("Lars Ingebrigtsen" -10000)
       ("Per Abrahamsen")
       ("larsi\\|lmi" -50000 nil R))
      ("subject"
       ("Ding is Badd" nil 728373))
      ("xref"
       ("alt.politics" -1000 728372 s))
      ("lines"
       (2 -100 nil <))
      (mark 0)
      (expunge -1000)
      (mark-and-expunge -10)
      (read-only nil)
      (orphan -10)
      (files "/hom/larsi/News/gnu.SCORE")
      (eval (ding)))

This example demonstrates absolutely everything about a score file.

Even though this looks much like lisp code, nothing here is actually evaled.  The lisp reader is used to read this form, though, so it has to be legal syntactically, if not semantically.

Six keys are supported by this alist:

STRING
     If the key is a string, it is the name of the header to perform the match on.  Scoring can only be performed on these eight headers: From, Subject, References, Message-ID, Xref, Lines, Chars and Date.  In addition to these headers, there are three strings to tell Gnus to fetch the entire article and do the match on larger parts of the article: Body will perform the match on the body of the article, Head will perform the match on the head of the article, and All will perform the match on the entire article.  Note that using any of these last three keys will slow down group entry considerably.

     Following this key is a random number of score entries, where each score entry has one to four elements.

      1. The first element is the match element.  On most headers this will be a string, but on the Lines and Chars headers, this must be an integer.

      2. If the second element is present, it should be a number - the score element.  This number should be an integer in the neginf to posinf interval.  This number is added to the score of the article if the match is successful.  If this element is not present, the gnus-score-interactive-default-score number will be used instead.

      3. If the third element is present, it should be a number - the date element.  This date says when the last time this score entry matched, which provides a mechanism for expiring the score entries.  It this element is not present, the score entry is permanent.  The date is represented by the number of days since December 31, 1 ce.

      4. If the fourth element is present, it should be a symbol - the type element.  This element specifies what function should be used to see whether this score entry matches the article.  What match types that can be used depends on what header you wish to perform the match on.

          From, Subject, References, Xref, Message-ID
               For most header types, there are the r and R (regexp) as well as s and S (substring) types.  If this element is not present, Gnus will assume that substring matching should be used. R and S differ from the other two in that the matches will be done in a case-sensitive manner.  All these one-letter types are really just abbreviations for the regexp and string types, which you can use instead, if you feel like.

          Lines, Chars
               These two headers use different match types: <, >, =, >= and <=.

          Date
               For the Date header we have three match types: before, at and after.  I can't really imagine this ever being useful, but, like, it would feel kinda silly not to provide this function.  Just in case.  You never know.  Better safe than sorry.  Once burnt, twice shy. Don't judge a book by its cover.  Never not have sex on a first date.

          Head, Body, All
               These three match keys use the same match types as the From (etc) header uses.

mark
     The value of this entry should be a number.  Any articles with a score lower than this number will be marked as read.

expunge
     The value of this entry should be a number.  Any articles with a score lower than this number will be removed from the summary buffer.

mark-and-expunge
     The value of this entry should be a number.  Any articles with a score lower than this number will be marked as read and removed from the summary buffer.

files
     The value of this entry should be any number of file names.  These files are assumed to be score files as well, and will be loaded the same way this one was.

exclude-files
     The clue of this entry should be any number of files.  This files will not be loaded, even though they would normally be so, for some reason or other.

eval
     The value of this entry will be evalel.  This element will be ignored when handling global score files.

read-only
     Read-only score files will not be updated or saved.  Global score files should feature this atom (see Global Score Files).

orphan
     The value of this entry should be a number.  Articles that do not have parents will get this number added to their scores.

Score File Editing
------------------

You normally enter all scoring commands from the summary buffer, but you might feel the urge to edit them by hand as well, so we've supplied you with a mode for that.

It's simply a slightly customized emacs-lisp mode, with these additional commands:

C-c C-c
     Save the changes you have made and return to the summary buffer (gnus-score-edit-done).

C-c C-d
     Insert the current date in numerical format (gnus-score-edit-insert-date).  This is really the day number, if you were wondering.

Scoring Tips
------------

Crossposts
     If you want to lower the score of crossposts, the line to match on is the Xref header.

          ("xref" (" talk.politics.misc:" -1000))

Multiple crossposts
     If you want to lower the score of articles that have been crossposted to more than, say, 3 groups:

          ("xref" (" +[^ ]+:[0-9]+ +[^ ]+:[0-9]+ +[^ ]+:[0-9]+" -1000 nil r))

Matching on the body
     This is generally not a very good idea - it takes a very long time. Gnus actually has to fetch each individual article from the server.  But you might want to anyway, I guess.  Even though there are three match keys (Head, Body and All), you should choose one and stick with it in each score file.  If you use any two, each article will be fetched twice.  If you want to match a bit on the Head and a bit on the Body, just use All for all the matches.

Marking as read
     You will probably want to mark articles that has a score below a certain number as read.  This is most easily achieved by putting the following in your all.SCORE file:

          ((mark -100))

     You may also consider doing something similar with expunge.

Reverse Scoring
---------------

If you want to keep just articles that have Sex with Emacs in the subject header, and expunge all other articles, you could put something like this in your score file:

     (("subject"
       ("Sex with Emacs" 2))
      (mark 1)
      (expunge 1))

So, you raise all articles that match Sex with Emacs and mark the rest as read, and expunge them to boot.

Global Score Files
------------------

Sure, other newsreaders have "global kill files".  These are usually nothing more than a single kill file that applies to all groups, stored in the user's home directory.  Bah!  Puny, weak newsreaders!

What I'm talking about here are Global Score Files.  Score files from all over the world, from users everywhere, uniting all nations in one big, happy score file union!  Ange-score!  New and untested!

All you have to do to use other people's score files is to set the gnus-global-score-files variable.  One entry for each score file, or each score file directory.  Gnus will decide by itself what score files are applicable to which group.

Say you want to use all score files in the /ftp@ftp.some-where:/pub/score directory and the single score file /ftp@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE:

     (setq gnus-global-score-files
           '("/ftp@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE"
             "/ftp@ftp.some-where:/pub/score/"))

Simple, eh?  Directory names must end with a /.  These directories are typically scanned only once during each Gnus session. If you feel the need to manually re-scan the remote directories, you can use the gnus-score-search-global-directories command.

Note that, at present, using this option will slow down group entry somewhat.  (That is - a lot.)

If you want to start maintaining score files for other people to use, just put your score file up for anonymous ftp and announce it to the world.  Become a retro-moderator!  Participate in the retro-moderator wars sure to ensue, where retro-moderators battle it out for the sympathy of the people, luring them to use their score files on false premises!  Yay!  The net is saved!

Here are some tips for the would-be retro-moderator, off the top of my head:

  * Articles that are heavily crossposted are probably junk.

  * To lower a single inappropriate article, lower by Message-Id.

  * Particularly brilliant authors can be raised on a permanent basis.

  * Authors that repeatedly post off-charter for the group can safely be lowered out of existence.

  * Set the mark and expunge atoms to obliterate the nastiest articles completely.

  * Use expiring score entries to keep the size of the file down.  You should probably have a long expiry period, though, as some sites keep old articles for a long time.

... I wonder whether other newsreaders will support global score files in the future.  Snicker.  Yup, any day now, newsreaders like Blue Wave, xrn and 1stReader are bound to implement scoring.  Should we start holding our breath yet?

Kill Files
----------

(ding) Gnus still supports those pesky old kill files.  In fact, the kill file entries can now be expiring, which is something I wrote before Per thought of doing score files, so I've left the code in there.

In short, kill processing is a lot slower (and I do mean a lot) than score processing, so it might be a good idea to rewrite your kill files into score files.

Anyway, a kill file is a normal emacs-lisp file.  You can put any forms into this file, which means that you can use kill files as some sort of primitive hook function to be run on group entry, even though that isn't a very good idea.

Normal kill files look like this:

     (gnus-kill "From" "Lars Ingebrigtsen")
     (gnus-kill "Subject" "ding")
     (gnus-expunge "X")

This will mark every article written by me as read, and remove them from the summary buffer.  Very useful, you'll agree.

Two functions for entering kill file editing:

V k
     Edit this group's kill file (gnus-summary-edit-local-kill).

V K
     Edit the general kill file (gnus-summary-edit-global-kill).

A kill file for the group soc.motss is normally called soc.motss.KILL.  The suffix appended to the group name to get this file name is detailed by the gnus-kill-file-name variable. The "global" kill file (not in the score file sense of "global", of course) is called just KILL.

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 Process/Prefix).

V m e
     Expire all expirable articles in the group (gnus-summary-expire-articles).

V m 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).

V m m
     Move the article from one mail group to another (gnus-summary-move-article).

V m c
     Copy the article from one group (mail group or not) to a mail group (gnus-summary-copy-article).

V m r
     Respool the mail article (gnus-summary-move-article).

V m 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).

Various Summary Stuff
=====================

gnus-summary-prepare-hook 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.

Group Information
-----------------

V 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. ange-ftp will be used for fetching the file.

V d
     Give a brief description of the current group (gnus-summary-describe-group).  If given a prefix, force rereading the description from the server.

V ?
     Give a very brief description of the most important summary keystrokes (gnus-summary-describe-briefly).

V i
     Go to the Gnus info node (gnus-info-find-node).

Searching for Articles
----------------------

V C-s
     Search through all subsequent articles for a regexp (gnus-summary-search-article-forward).

V C-r
     Search through all previous articles for a regexp (gnus-summary-search-article-backward).

V &
     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).

V u
     Perform any operation on all articles that have been marked with the process mark (gnus-summary-universal-argument).

Really Various Summary Commands
-------------------------------

V D
     If the current article is a digest, you might use this command to enter you into a group based on the current digest to ease reading (gnus-summary-enter-digest-group).  See nndigest.

V T
     Toggle truncation of summary lines (gnus-summary-toggle-truncation).

V e
     Expand the summary buffer window (gnus-summary-expand-window).

V S
     Exit this group, and then enter it again (gnus-summary-reselect-current-group).  If given a prefix, select all articles, both read and unread.

V 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.

The Article Buffer
******************

The articles are displayed in the article buffer, of which there is only one.  All the summary buffer share the same article buffer.

Hiding Headers
==============

The top section of each article is the head.  (The rest is the body, but you may have guessed that already.)

There is a lot of useful information in the head: the name of the person who wrote the article, the date it was written and the subject of the article.  That's well and nice, but there's also lots of information most people do not want to see - what systems the article has passed through before reaching you, the Message-Id, the References, etc. ad nauseum - and you'll probably want to get rid of some of those lines.  If you want to keep all those lines in the article buffer, you can set gnus-show-all-headers to t.

Gnus provides you with two variables for sifting headers:

gnus-visible-headers
     If this variable is non-nil, it should be a regular expression that says what headers you wish to keep in the article buffer.  All headers that do not match this variable will be hidden.

     For instance, if you only want to see the name of the person who wrote the article and the subject, you'd say:

          (setq gnus-visible-headers "^From:\\|^Subject:")

gnus-ignored-headers
     This variable is the reverse of gnus-visible-headers.  If this variable is set (and gnus-visible-headers is nil), it should be a regular expression that matches all lines that you want to hide.  All lines that do not match this variable will remain visible.

     For instance, if you just want to get rid of the References line and the Xref line, you might say:

          (setq gnus-ignored-headers "^References:\\|^Xref:")

     Note that if gnus-visible-headers is non-nil, this variable will have no effect.

Gnus can also sort the headers for you.  (It does this by default.)  You can control the sorting by setting the gnus-sorted-header-list variable.  It is a list of regular expressions that says in what order the headers are to be displayed.

For instance, if you want the name of the author of the article first, and then the subject, you might say something like:

     (setq gnus-sorted-header-list '("^From:" "^Subject:"))

Any headers that are to remain visible, but are not listed in this variable, will be displayed in random order after all the headers that are listed in this variable.

Using Mime
==========

Mime is a standard for waving your hands through the air, aimlessly, while people stand around yawning.

MIME, however, is a standard for encoding your articles, aimlessly, while all newsreaders die of fear.

MIME may specify what character set the article uses, the encoding of the characters, and it also makes it possible to embed pictures and other naughty stuff in innocent-looking articles.

Gnus handles MIME by shoving the articles through gnus-show-mime-method, which is metamail-buffer by default.  Set gnus-show-mime to t if you want to use MIME all the time; it might be best to just use the toggling functions from the summary buffer to avoid getting nasty surprises. (For instance, you enter the group alt.sing-a-long and, before you know it, MIME has decoded the sound file in the article and some horrible sing-a-long song comes streaming out out your speakers, and you can't find the volume button, because there isn't one, and people are starting to look at you, and you try to stop the program, but you can't, and you can't find the program to control the volume, and everybody else in the room suddenly decides to look at you disdainfully, and you'll feel rather stupid.)

Any similarity to real events and people is purely coincidental.  Ahem.

Customizing Articles
====================

The gnus-article-display-hook is called after the article has been inserted into the article buffer.  It is meant to handle all treatment of the article before it is displayed.  By default it contains gnus-article-hide-headers, which hides unwanted headers.

Other useful functions you might add to this hook is gnus-article-hide-citation (which hides all cited text); gnus-article-hide-signature (which, umn, hides the signature); gnus-article-subcite (which tries to clean up the mess supercite makes in The Hands Of The Mad); gnus-article-treat-overstrike (which treats ^H_ in a reasonable manner); gnus-article-remove-cr (which removes trailing carriage returns); gnus-article-de-quoted-unreadble (which does a naive decoding of articles encoded with Quoted-Printable); and gnus-article-display-x-face (which displays any X-Face headers).

You can, of course, write your own functions.  The functions are called from the article buffer, and you can do anything you like, pretty much. There is no information that you have to keep in the buffer - you can change everything.  However, you shouldn't delete anu headers.  Instead make them invisible if you want to make them go away.

Article Keymap
==============

Most of the keystrokes in the summary buffer can also be used in the article buffer.  They should behave as if you typed them in the summary buffer, which means that you don't actually have to have a summary buffer displayed while reading.  You can do it all from the article buffer.

A few additional keystrokes are available:

SPACE
     Scroll forwards one page (gnus-article-next-page).

DEL
     Scroll backwards one page (gnus-article-prev-page).

C-c ^
     If point is in the neighborhood of a Message-Id and you press r, Gnus will try to get that article from the server (gnus-article-refer-article).

C-c C-m
     Send a reply to the address near point (gnus-article-mail).

C-c C-M
     Send a reply to the address near point and include the original article (gnus-article-mail-with-original).

s
     Reconfigure the buffers so that the summary buffer becomes visible (gnus-article-show-summary).

?
     Give a very brief description of the available keystrokes (gnus-article-describe-briefly).

Misc Article
============

gnus-article-prepare-hook
     This hook is called right after the article has been inserted into the article buffer.  It is mainly intended for functions that do something depending on the contents; it should probably not be used for changing the contents of the article buffer.

gnus-article-display-hook
     This hook is called as the last thing when displaying an article, and is intended for modifying the contents of the buffer, doing highlights, hiding headers, and the like.

gnus-article-mode-line-format
     This variable is a format string along the same lines as gnus-summary-mode-line-format.  It accepts exactly the same format specifications as that variable.

gnus-break-pages
     Controls whether page breaking is to take place.  If this variable is non-nil, the articles will be divided into pages whenever a page delimeter appears in the article.  If this variable is nil, paging will not be done.

gnus-page-delimeter
     This is the delimeter mentioned above.  By default, it is ^L (form linefeed).

The Server Buffer
*****************

Traditionally, a server is a machine or a piece of software that one connects to, and then requests information from.  Gnus does not connect directly to any real servers, but does all transactions through one backend or other.  But that's just putting one layer more between the actual media and Gnus, so we might just as well say that each backend represents a virtual server.

For instance, the nntp backend may be used to connect to several different actual nntp servers, or, perhaps, to many different ports on the same actual nntp server.  You tell Gnus which backend to use, and what parameters to set by specifying a select method.

These select methods specifications can sometimes become quite complicated - say, for instance, that you want to read from the nntp server news.funet.fi on port number 13, which hangs if queried for NOV headers and has a buggy select.  Ahem.  Anyways, if you had to specify that for each group that used this server, that would be too much work, so Gnus offers a way of putting names to methods, which is what you do in the server buffer.

Server Buffer Format
====================

You can change the look of the server buffer lines by changing the gnus-server-line-format variable.  This is a format-like variable, with some simple extensions:

h
     How the news is fetched - the backend name.

n
     The name of this server.

w
     Where the news is to be fetched from - the address.

Server Commands
===============

SPC
     Browse the current server (gnus-server-read-server).

q
     Return to the group buffer (gnus-server-exit).

l
     List all servers (gnus-server-list-servers).

k
     Kill the current server (gnus-server-kill-server).

y
     Yank the previously killed server (gnus-server-yank-server).

c
     Copy the current server (gnus-server-copy-server).

a
     Add a new server (gnus-server-add-server).

e
     Edit a server (gnus-server-edit-server).

Example Methods
===============

Most select methods are pretty simple and self-explanatory:

     (nntp "news.funet.fi")

Reading directly from the spool is even simpler:

     (nnspool "")

As you can see, the first element in a select method is the name of the backend, and the second is the address, or name, if you will.

After these two elements, there may be a random number of (VARIABLE FORM) pairs.

To go back to the first example - imagine that you want to read from port 15 from that machine.  This is what the select method should look like then:

     (nntp "news.funet.fi" (nntp-port-number 15))

You should read the documention to each backend to find out what variables are relevant, but here's an nnmh example.

nnmh is a mail backend that reads a spool-like structure.  Say you have two structures that you wish to access: One is your private mail spool, and the other is a public one.  Here's the possible spec for you private mail:

     (nnmh "private" (nnmh-directory "~/private/mail/"))

(This server is then called private, but you may have guessed that.

Here's the method for the public spool:

     (nnmh "public"
           (nnmh-directory "/usr/information/spool/")
           (nnmh-get-new-mail nil))

Servers & Methods
=================

Various
*******

Interactive
===========

gnus-novice-user
     If this variable is non-nil, you are either a newcomer to the World of Usenet, or you are very cautious, which is a nice thing to be, really.  You will be given questions of the type "Are you sure you want to do this?" before doing anything dangerous.

gnus-expert-user
     If this variable is non-nil, you will never ever be asked any questions by Gnus.  It will simply assume you know what your are doing, no matter how strange.

gnus-interactive-catchup
     Require confirmation before catching up a group if non-nil.

gnus-interactive-post
     If non-nil, the user will be prompted for a group name when posting an article.

gnus-interactive-exit
     Require confirmation before exiting Gnus.

Windows Configuration
=====================

No, there's nothing here about X, so be quiet.

gnus-use-full-window
     If non-nil, Gnus will delete all other windows and occupy the entire Emacs screen by itself.  It is t by default.

gnus-window-configuration
     This variable describes how much space each Gnus buffer should be given, compared to the other Gnus buffers.  Here's an example:

          (setq gnus-window-configuration
            '((summary (0 1 0))
              (groups (1 0 0))
              (article (0 3 10))))

     This variable is a list of lists, where each of these small lists is on the form (ACTION (G S A)).  As you can see, there are three possible ACTIONs - group (which is what happens when you first start Gnus, or returns from the summary buffer), summary (which is what happens when there are no unread articles in the group, and article (which is what happens when there is an unread article in the group).

     We see that in the first two actions, the respective buffers will fill the screen, and in the last, the article buffer will take ten lines for each three the summary buffer gets.

     This variable can also have a function as its value.  In that case, whenever Gnus tries to configure the Gnus buffers, that function will be called with the ACTION as its parameter.  There is one pre-made function supplied, gnus-window-configuration-split, which may be suitable if you have a very wide Emacs window, and want to have the summary buffer and the article buffer side by side.

Various Various
===============

gnus-updated-mode-lines
     This is a list of buffers that should keep their mode lines updated. The list may contain the symbols group, article and summary.  If the corresponding symbol is present, Gnus will keep that mode line updated with information that may be pertinent.  If this variable is nil, screen refresh may be quicker.

gnus-mode-non-string-length
     By default, Gnus displays information on the current article in the mode lines of the summary and article buffers.  The information Gnus wishes to display (eg. the subject of the article) is often longer than the mode lines, and therefore have to be cut off at some point.  This variable says how long the other elements on the line is (ie. the non-info part).  If you put additional elements on the mode line (eg. a clock), you should modify this variable:

          (add-hook 'display-time-hook
          	  (lambda ()
          	    (setq gnus-mode-non-string-length
          		  (+ 21 (length display-time-string)))))

gnus-visual
     If nil, Gnus won't attempt to create menus or use fancy colours or fonts.  This will also inhibit loading the gnus-visual.el file.

gnus-mouse-face
     This is the face (ie. font) used for mouse highlighting in Gnus.  No mouse highlights will be done if gnus-visual is nil.

Customization
*************

All variables are properly documented elsewhere in this manual.  This section is designed to give general pointers on how to customize Gnus for some quite common situations.

Slow NNTP Connection
====================

If you run Emacs on a machine locally, and get your news from a machine over some very thin strings, you want to cut down on the amount of data Gnus has to get from the NNTP server.

gnus-read-active-file
     Set this to nil, which will inhibit Gnus from requesting the entire active file from the server.  This file is often v.  large.  You also have to set gnus-check-new-news and gnus-check-bogus-newsgroups to nil to make sure that Gnus doesn't suddenly decide to fetch the active file anyway.

gnus-nov-is-evil
     This one has to be nil.  If not, grabbing article headers from the NNTP server will not be very fast.  Not all NNTP servers support XOVER; Gnus will detect this by itself.

Slow Terminal Connection
========================

Let's say you use your home computer for dialling up the system that runs Emacs and Gnus.  If your modem is slow, you want to reduce the amount of data that is sent over the wires as much as possible.

gnus-auto-center-summary
     Set this to nil to inhibit Gnus from recentering the summary buffer all the time.

gnus-visible-headers
     Cut down on the headers that are included in the articles to the minimum.  You can, in fact, make do without them altogether - most of the useful data is in the summary buffer, anyway.  Set this variable to "^NEVVVVER" or "From:", or whatever you feel you need.

gnus-article-display-hook
     Set this hook to all the available hiding commands:

          (setq gnus-article-display-hook
                '(gnus-article-hide-headers gnus-article-hide-signature
                  gnus-article-hide-citation))

gnus-use-full-window
     By setting this to nil, you can make all the windows smaller. While this doesn't really cut down much generally, it means that you have to see smaller portions of articles before deciding that you didn't want to read them anyway.

gnus-thread-hide-subtree
     If this is non-nil, all threads in the summary buffer will be hidden initially.

gnus-updated-mode-lines
     If this is nil, Gnus will not put information in the buffer mode lines, which might save some time.

Little Disk Space
=================

The startup files can get rather large, so you may want to cut their sizes a bit if you are running out of space.

gnus-save-newsrc-file
     If this is nil, Gnus will never save .newsrc - it will only save .newsrc.eld.  This means that you will not be able to use any other newsreaders than Gnus.

gnus-save-killed-list
     If this is nil, Gnus will not save the list of dead groups.  You should also set gnus-check-new-newsgroups to ask-server and gnus-check-bogus-newsgroups to nil if you set this variable to nil.

Slow Machine
============

If you have a slow machine, or are just really impatient, there are a few things you can do to make Gnus run faster.

Setgnus-check-new-newsgroups and gnus-check-bogus-newsgroups to nil to make startup faster.

Set gnus-show-threads, gnus-use-cross-reference and gnus-nov-is-evil to nil to make entering and exiting the summary buffer faster.

Set gnus-article-display-hook to nil to make article processing a bit faster.

Troubleshooting
***************

(ding) Gnus works so well straight out of the box - I can't imagine any problems, really.

Ahem.

 1. Make sure your computer is switched on.

 2. Make sure that you really load the current Gnus version.  If you have been running GNUS, you need to exit Emacs and start it up again before Gnus will work.

 3. Try doing an M-x gnus-version.  If you get something that looks like (ding) Gnus v0.46; nntp 4.0 you have the right files loaded. If, on the other hand, you get something like NNTP 3.x or nntp flee, you have some old .el files lying around. Delete these.

 4. Read the help group (M h in the group buffer) for a FAQ and a how-to.

If all else fails, report the problem as a bug,

If you find a bug in (ding) Gnus, you can report it with the M-x gnus-bug command.  (setq debug-on-error t), and send me the backtrace.  I will fix bugs, but I can only fix them if you send me a precise description as to how to reproduce the bug.

The End
*******

Well, that's the manual - you can get on with your life now.  Keep in touch.  Say hello to your cats from me.

My ghod - I just can't stand goodbyes.  Sniffle.

Ol' Chuck Reznikoff said it pretty well, so I leave the floor to him:

     Te Deum

     Not because of victories

     I sing,

     having none,

     but for the common sunshine,

     the breeze,

     the largess of the spring.

     Not for victory

     but for the day's work done

     as well as I was able;

     not for a seat upon the dais

     but at the common table.