Man Linux: Main Page and Category List


       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

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

       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

       immediate_blits=bool [default=no]

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

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

       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

       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

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


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

       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

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

       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

       log_illegal_mem [default=no]

       If enabled, print illegal memory accesses


       $HOME/.uaerc user configuration file.