Basic:

    Once you've got germ pointed at the right directory, it knows it's own
    name and you've changed the dat directory's permissions to 775 things
    are pretty simple.
    
    To write a post, create a file in your favorite text editor.  The
    first line should be the entry's title, unless you are using tags,
    then defer it to the second line and see below.  Next hit
    return twice to leave a gap between your title and your entry and then
    type away.  Try to limit your lines to 80 columns or (perhaps even
    better) the RFC-1436 recommended 70 columns.  However, should you
    prefer hideously long lines that may not work on terminal clients, you
    can do that (you just shouldn't).
    
    One tip to help you when posting indented text or source code, be sure
    to set your editor of choice to convert tabs to spaces. Lines starting
    with <TAB> characters don't get displayed as 'inline text' by the
    gopher server.
    
To use tags:
    
    
    The first line can be a list of comma-separated tags, which get
    parsed and converted to a link that when clicked, will display all
    posts containing that tag. The format looks like this:
    
    #Tags Linux,Sysadmin,Tips
    
    this will also work:
    
    #tags Sysadmin, Tips and Tricks,linux
    
    The space after the '#Tags' and before the list of tags is mandatory.
    Tags are not case-sensitive, so "Linux" and "linux" link to the same tag.
    Spaces around the commas get stripped. Spaces within tags are allowed, 
    but punctuation is not.
    
    Tags are also allowed in the second line of the post to maintain
    compatability with germ 2.0's tag system.  Whether you place the
    tag on the first or second line will not affect the appearance of 
    your gopherlog.  Tags on any other lines will be treated as normal 
    text.
    
To shorten posts:
    
    You can also shorten your post, by adding this text on a line by
    itself somewhere in your post:

    --more--
    
    On the index, archive, and tag pages, anything after this line is not
    displayed. This will cut down on the size of the main index page once
    you fill it with a lot of posts.
    
To use links:

    Germ will do its best to detect lines with gophermap-style links, and
    display them as-is (rather than as inline-text). The server and port
    are required. Here is an example:
    
    0germ.cgi<TAB>/users/slugmax/code/germ-0.2.cgi<TAB>sdf.lonestar.org<TAB>70
    9germ-0.2.tgz<TAB>/users/slugmax/code/germ-0.2.tgz<TAB>sdf.lonestar.org<TAB>70

    Where "<TAB>" is the tab character, not spaces.  It doesn't work with 
    spaces.

To save and publish your post:

    When you're done, save your entry in your dat directory with a format
    like this FILENAME.post.  If it doesn't end in ".post", germ ignores
    it and your post languishes.  Make sure it's readable.  A quick "chmod
    644 FILENAME.post" can do that for you (You can change this extension
    - see the INSTALL document for an explanation, or just change the
    $post_ext variable).
    
    After that, you're done.  Germ handles the dating, displaying, and
    archiving of your posts.  It also handles the creation, maitanence,
    and dating of your comment files, stored in "FILENAME.post.cmt".

To customize:

    To customize your header or divider, simply edit the header.txt or
    div.txt file in your dat directory.
    
    You can also customize the text that goes in the link to your individual
    posts and the text displayed when you shorten a post by editing the 
    variables $permalink_text and $more_text respectively which are in 
    Configurable Variables in the script's header.  These texts are generated 
    dynamically so it will change for all posts, old and new.  
    
    You can also customize the divider between comments, and the divider 
    between posts and tags by editing the variable $cmt_div.  Once you 
    have recieved comments, changing this is inadvisable, as it will
    ruin comment counts.

To use as a static phlog maker:

    Currently, germ natively supports only dynamic gopherlogs, because
    that's what it was designed to do.  However, if you wish, you can
    wrangle it into a semblence of static blogging.
    
    Running a command at the command line like:
    
    $germ.cgi > phlog
    
    will create a static front page linking to dynamically generated posts
    and archives.
    
    Similar prompts, such as:
    
    $germ.cgi archive1 > archive1
    $germ.cgi FILENAME.post > FILENAME.post  (this one's potentially dangerous)
    
    will create static pages of your archives and posts with a few
    caveats.
    
    If you are running prompts like "$germ.cgi FILENAME.post >
    FILENAME.post in your dat directory you will overwrite your original
    post which can make a mess of things, especially if you go back to
    running germ as a dynamic script.
    
    The other major problem with this is you'd need to manually edit each
    file to create the proper links, changing things like:
    
    1Older Posts<TAB>/users/username/germ.cgi?archive1
    to
    1Older Posts<TAB>/users/username/archive1
    
    which could be kind of a pain.  Also, once you have a lot of entries
    it would get to be a hassle to create a new main page, new archive
    pages one new post page and edit them all by hand each time you added
    a new post.  Oh, and every time someone posted a comment, you'd have
    to regenerate and reedit the post they commented on.
    
    I may make germ more static gopherlog friendly in the future, but it's
    not a top priority.
