Provided by: uae_0.8.29-7_amd64 bug


       uae - The Ubiquitous Amiga Emulator


       uae [ -h ] [ -f file ] { -s opt=val }


       This  manual page was produced for uae 0.8.12.  It is only provided for convenience by the
       maintainer of the Debian package of uae. Please  see  /usr/share/doc/uae  for  a  thorough
       description. The following chapters are simply snippets from the upstream README.

       Btw, in my experience, the "-h" switch for some reasons does not work for uae 0.8.x.


       An  emulator  is  a program which enables you to run software for a machine which has non-
       native hardware and a non-native operating system, on your computer.  UAE  allows  you  to
       run  most  of  the  available  Amiga software. It is a software emulation, meaning that no
       extra or special hardware is needed to do this. The  hardware  of  an  Amiga  is  emulated
       accurately,  so  that  Amiga  software  is tricked into thinking it is running on the real
       thing, with your computer's display, keyboard, harddisk and  mouse  taking  the  parts  of
       their emulated counterparts.

       UAE  was developed for Unixoid systems. Meanwhile, it has been ported to the Mac, DOS, the
       BeBox, NextStep, the XFree86/OS2 environment and the Amigas (it can run  itself  by  now).
       You  should have received several other files along with this document with details on how
       to install and use the version for your operating system.

       This section is just what it says: an overview. Please read _all_ of this file, especially
       if  you have problems. UAE has many, many features and equally many configuration options.
       If you don't know about them, it's likely that UAE doesn't work for you, or  doesn't  work
       as good as it could.

       Please  read  also the file "FAQ" which contains some Frequently Asked Questions (and even
       the answers!) You should also look for a document describing the specific port of  UAE  to
       the operating system you are using, for example "BeOS/README" or "DOS/README".

       People  have  complained  that  the UAE documentation contains only "weird jargon".  Sorry
       about this. Despite what MessySoft and Tomato tell you, computer  programs  aren't  always
       easy  to use. UAE does require some assistance from you, and therefore you should at least
       understand a bit about computers. After all, you are an Amiga fan, so you should know what
       a Workbench is, don't you think?


       First,  read  the system-specific documents for information how to set up UAE.  You should
       have an executable program called "uae". You can simply  execute  it,  but  you  can  also
       optionally give it one or more of the following parameters:

        -h              : Print out a help text.
        -f file         : Load a configuration file.
        -s opt=val      : Set the emulator's option "opt" to value "val".

       Configuration  files consist of several lines of the form "opt=val", just as with the "-s"
       parameter.  You can use the following options with the "-s" option, or in a  config  file.
       [Here,  "=n"  means  the option takes a number as value.  "=bool" means the option takes a
       value of either "yes" or "no" (or "true", "false", or  abbreviations  of  any  of  these).
       There are other classes as well.]

       General options:

       accuracy=n [default=2]

       Set  emulator accuracy to n. The default is n = 2, which means the emulator will try to be
       as accurate as possible. This no longer does much  in  this  version,  and  I'll  probably
       remove it.

       framerate=n [default=1]

       Sets the frame rate to 1/n. Only every nth screen will be drawn.  Using a higher value can
       speed up the emulator, at the expense of graphics quality.

       autoconfig=bool [default=yes]

       If this is enabled, all expansion devices provided by the emulation will  be  automounted.
       You should only disable this if you have a Kickstart ROM earlier than 1.3 which can't cope
       with this. Some badly written games and demos might also be incompatible with this.

       kbd_lang=lang [default=us]

       Set the keyboard language. Currently, the following values can  be  used:  "us"  for  U.S.
       keyboard (default), "se" for swedish, "fr" for french, "it" for italian, "es" for spanish,
       or "de" for german keyboard.  This setting only affects the X11 version.

       floppy0=file [default=df0.adf]

       Try to use the specified file as diskfile for drive 0 instead  of  df0.adf.   The  options
       floppy1, floppy2, and floppy3 also exist.

       kickstart_rom_file=file [default=kick.rom]

       Use the specified file instead of kick.rom as Kickstart image.

       joyport0=mode [default=mouse]

       Specify  how to emulate joystick port 0. You can use "mouse", "joy0", or "joy1" to use the
       corresponding input devices of your machine, or you can select several different  keyboard
       replacements  for  a  joystick: "kbd1" for the numeric pad with '0' as fire button, "kbd2"
       for the cursor keys with right control as fire button and c is T/F/H/B with  Alt  as  fire

       joyport1=mode [default=joy0]

       Like joyport0, but for the Amiga's joystick port 1.

       use_gui=bool [default=yes]

       Show a user-interface that enables changing these options at run-time.

       32bit_blits=bool [default=no]

       If  enabled,  the blitter emulation will use 32 bit operations where that seems profitable
       (note that this will cause bus errors on most  RISC machines)

       immediate_blits=bool [default=no]

       If enabled, all blits will finish immediately, which can be nice for speed, but may  cause

       cpu_speed=speed [default=4]

       This  can  have a value of "real", "max", or an integer between 1 and 20.  "real" will try
       to give the CPU emulation exactly as many cycles, relative to the other  chips,  as  on  a
       real  A500.  "max" will try to give you the maximum CPU emulation speed achievable on your
       machine.  Numeric values specify a fixed relation between CPU and custom  chip  emulation,
       where  lower  values  prioritize CPU emulation, while higher values prioritize custom chip

       cpu_type=type [default=68000]

       Controls which CPU is emulated. This can be "68000", "68010",  "68020"  or  "68020/68881".
       In  some  cases,  you  may  need to use "68ec020" or "68ec020/68881" to emulate a crippled
       variant of the 68020 that has only a 24 bit address bus.  Some  software,  including  some
       Kickstart  versions,  does  not  work  with  a normal 68020 that has a 32 bit address bus.
       Careful: using an "ec" variant has harmful side effects, and  should  be  disabled  unless
       absolutely needed (you lose Z3 memory and Picasso emulation).

       cpu_compatible=bool [default=no]

       If enabled, a slower but slightly more accurate variant of the CPU emulation will be used.
       This is needed for some types of  copy  protection,  among  other  things.  This  is  only
       meaningful for a CPU type of "68000".

       Emulating external devices (harddisk, CD-ROM, printer, serial port):

       filesystem=access,volume:path [default=no filesystems mounted]

       Mount  the host's file system at "path" as an Amiga filesystem with volume name "VOLUME:".
       "access" can be either "ro" (for readonly), or "rw" (for  read-write).   If  you  want  to
       mount  a  CD-ROM,  you  should use a readonly mount.  You can mount multiple file systems.
       See below.

       hardfile=access,secs,heads,reserved,bsize,file [default=no hardfiles mounted]

       Mount the hardfile "file" as an emulated harddisk, using a geometry of "secs" sectors  per
       track,  "heads" surfaces and "nr" reserved blocks.  Each sector should have "bsize" bytes.
       This can be abused to mount floppy images.  You can mount multiple hardfiles.  See below.

       Sound options:

       sound_output=type [default=none]

       The type of sound output can be "none" (no sound at all), "interrupts" (emulated  for  the
       internal  side  effects  that  can  be noticed by programs, but no sound output), "normal"
       (emulated, and sound output), "exact" (a slightly more  accurate  emulation  that  may  be
       necessary in some cases, but can also be slower).

       sound_channels=type [default=mono]

       Can be "mono" or "stereo".

       sound_bits=n [default varies across UAE versions on different OS types]

       Common values are 8 (low quality) or 16 (high quality)

       sound_frequency=n [default varies across UAE versions on different OS types]

       Common  values  are  22050  or  44100.  The  quality  of  sound  output increases with the


       sound_max_buff=n [default varies across UAE versions on different OS types]

       You can specify the minimum and maximum size of the sound buffer.  Smaller buffers  reduce
       latency.  Usually only the minimum size is used.

       sound_interpol=type [default none]

       Normally,  sound  samples  are  output  exactly  as  they  are computed, without any post-
       processing.  This can generate errors in the sound output when the output frequency  isn't
       an  even  multiple  of the input frequency.  These errors are usuable perceived as a high-
       frequency noise.  There are currently two types of  interpolation  available,  both  under
       experimentation.   You  can use either "rh" or "crux" as value for this option.  Note that
       no interpolation is supported for 8 bit output; you need to use 16 bit output  to  hear  a
       difference.  If you have any comments about the effects of either method on audio quality,
       I'd be very interested to hear them.

       Memory options:

       bogomem_size=n [default=0]

       Emulate n*256K slow memory at 0xC00000. Some demos/games need this.

       fastmem_size=n [default=0]

       Emulate n megabytes of fast memory as an expansion board.

       z3mem_size=n [default=0]

       Emulate n megabytes of Zorro III fast memory as an expansion board.

       chipmem_size=n [default=4]

       Emulate n*512K chip memory. Some very broken programs need specific amounts of chip mem to
       work properly. The largest valid value is 16, which means 8MB chip memory.

       Display options:

       gfx_width=n [default=800]

       Use a window that is n pixels wide for displaying the Amiga screen.

       gfx_height=n [default=300]

       Use a window that is n pixels high for displaying the Amiga screen.

       gfx_lores=bool [default=no]

       Enable  this option if you use a very small window width (320 to 400 pixels) to shrink the
       display horizontally.

       gfx_linemode=type [default=none]

       The type can be none (every line is drawn once), "double" (every line is drawn twice), and
       "scanlines"  (every line is drawn once, but the image is stretched vertically by inserting
       a black line every other line to simulate the display on an old  monitor).   The  "double"
       mode  gives  best  results, but slows down the emulation quite a lot. Don't use the "none"
       mode if you want a decent interlace emulation.  If you use "double" or  "scanlines",  your
       window needs to be twice as high as when using the "none" mode.

       gfx_correct_aspect=bool [default=none]

       Try  to  fit  the image into the specified window dimensions by leaving out certain lines.
       Useful if you want to fit a 640x512 Amiga display in a 640x480 window.

       gfx_center_vertical=bool [default=no]

       gfx_center_horizontal=bool [default=no]

       If you use a smaller window than 800x300 (400x300 with "gfx_lores" option or 800x600  with
       a gfx_linemode other than "none"), not all parts of the display will fit on the screen. By
       enabling the necessary centering options, you can ask the emulator to  try  and  move  the
       screen  contents  so  that  the relevant parts are displayed. If you are unlucky, this can
       cause the contents to jump around a bit in certain cases.

       gfx_fullscreen_amiga=bool [default=no]

       Enable if you want to use the full screen, not a window on  the  desktop,  for  the  Amiga
       display.  Some ports (DOS, SVGAlib) always use fullscreen mode.

       gfx_fullscreen_picasso=bool [default=no]

       Like gfx_fullscreen_amiga, but for the Picasso graphics card display.

       gfx_color_mode=mode [default=8bit]

       Select  a  color mode to use.  Color modes: 8bit (256 colors), 15bit (32768 colors), 16bit
       (65536  colors),  8bit_dithered  (256  colors,  with  dithering   to   improve   quality),
       4bit_dithered (16 colors, dithered); 32bit (16 million colors)

       gfxcard_size=n [default=0]

       Emulate  a  Picasso  96 compatible graphics card with n MB graphics memory.  This requires
       that you use set the CPU type to "68020" or higher,  and  that  you  do  not  use  24  bit

       Debugging options (not interesting for most users):

       use_debugger=bool [default=no]

       If enabled, don't start the emulator at once, use the built-in debugger.

       log_illegal_mem [default=no]

       If enabled, print illegal memory accesses


       $HOME/.uaerc user configuration file.