UAE(1)							      Contributed application							    UAE(1)

NAME

       uae - The Ubiquitous Amiga Emulator

SYNOPSIS

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

PRELIMINARIES

       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.

OVERVIEW

       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  run-
       ning 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 fea-
       tures 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?

INVOKING UAE

       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  graph-
       ics 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 Kick-
       start 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 machines)

       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  protec-
       tion, 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 pro-
       grams, 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 frequency.

       sound_min_buff=n

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

       log_illegal_mem [default=no]

       If enabled, print illegal memory accesses

FILES

       $HOME/.uaerc user configuration file.

3rd party							    25 Feb 2001 							    UAE(1)