fuse(1)

NAME
fuse - Sinclair ZX Spectrum emulator

SYNOPSIS
fuse [options]

DESCRIPTION
Fuse is a Sinclair ZX Spectrum emulator. It supports several models (including the 128), with quite faithful emulation of the display and sound.

The emulator can load any of the formats supported by libspectrum(3) - this includes Z80, SNA and SZX snapshots, and TAP and TZX virtual-tape files. Saving to SZX, Z80 and SNA snapshots and TZX and TAP tape files is supported. The SLT extension to the Z80 format is partly supported (enough for multi-load games); however, loading of the old DAT-file variant is not. DSK disk images are supported when emulating a +3, TRD and SCL disk images are supported when emulating a Pentagon or Scorpion and DCK cartridge images are supported when emulating a TC2068. Interface II ROM cartridges are also supported.

Finally, there is also support for reading and writing the RZX input recording format.

See the COMPRESSED FILES section for details on reading files compressed with bzip2(3) or gzip(3).

OPTIONS
--aspect-hint
    Specify whether the GTK+ and Xlib user interfaces should `hint' to the window manager about the preferred aspect ratio for the top-level window, thus preventing resizing to non-square sizes which lead to Fuse not displaying correctly. However, with some window managers (for example icewm(1)) this prevents the window from being resized at all. (Enabled by default, but you can use `--no-aspect-hint' to disable).

--autosave-settings
    Specify whether Fuse's current settings should be automatically saved on exit. The same as the General Options dialog's Auto-save settings option.

--auto-load
    Specify whether tape and disk files should be automatically loaded when they are opened. (Enabled by default, but you can use `--no-auto-load' to disable). Same as the General Options dialog's Auto-load media option.

--beeper-stereo
    Specify whether fake stereo should be added to the emulation of the Spectrum beeper. Same as the Sound Option dialog's Beeper pseudo-stereo option.

--bw-tv
    Specify whether the display should simulate a colour or black and white television. This option is effective only under the GTK+ and SDL user interfaces: the others will always simulate a colour TV. The same as the General Option dialog's Black and white TV option.

--competition-code code
    Specify the code to be written to competition mode RZX files. The same as the RZX Options dialog's Competition code option.

--competition-mode
    Specify whether input recordings should be made in `competition mode'. The same as the RZX Options dialog's Competition mode option.

--compress-rzx
    Specify whether RZX files should be written out compressed. (Enabled by default, but you can use `--no-compress-rzx' to disable). Same as the RZX Options dialog's Compress RZX data option.

--confirm-actions
    Specify whether `dangerous' actions (those which could cause data loss, for example resetting the Spectrum) require confirmation before occuring. (Enabled by default, but you can use `--no-confirm-actions' to disable). This option is effective only under the GTK+ UI, and is the same as the General Options dialog's Confirm actions option.

--dock file
    Insert the specified file into the emulated Timex TC2068 dock; also select the TC2068 on startup if available.

--embed-snapshot
    Specify whether a snapshot should be embedded in an RZX file when recording is started from an existing snapshot. (Enabled by default, but you can use `--no-embed-snapshot' to disable). Same as the RZX Options dialog's Always embed snapshot option.

-g filter
--graphics-filter mode
    Specify which graphics filter to use if available. The default is normal, which uses no filtering. The available options are 2x, 2xsai, 3x, advmame2x, advmame3x, dotmatrix, half, halfskip, normal, super2xsai, supereagle, timex15x, timextv, and tv2x. See the GRAPHICS FILTERS section for more details.

--graphicsfile file
    Set the filename used for graphical output from the emulated ZX printer. See the PRINTER EMULATION section for more details.

-h
--help
    Give brief usage help, listing available options.

--if2cart file
    Insert the specified file into the emulated Interface II.

--interface2
    Emulate a Sinclair Interface II. Same as the Peripherals Options dialog's Interface II option.

--issue2
    Emulate an issue 2 keyboard. Same as the General Options dialog's Issue 2 keyboard option.

-j device
--joystick-1 device
    Read from device to emulate the first joystick. Fuse will use either `/dev/input/js0' or `/dev/js0' by default.

--joystick-2 device
    As for --joystick-1 but for the second joystick; the default here is either `/dev/input/js1' or `/dev/js1'.

--kempston
    Emulate a Kempston joystick. Same as the Peripherals Options dialog's Kempston joystick option.

--loading-sound
    Specify whether the sound made while tapes are loading should be emulated. (Enabled by default, but you can use `--no-loading-sound' to disable). Same as the Sound Option dialog's Loading sound option.

-m type
--machine type
    Specify machine type to emulate initially. The default is 48, a 48K Spectrum. The available options are 16, 48, 128, plus2, plus2a, plus3, 2048, 2068, and pentagon.

-p file
--playback file
    Specify an RZX file to begin playback from.

--plus3disk file
    Insert the specified file into the emulated +3's A: drive; also select the +3 on startup if available.

--printer
    Specify whether the emulation should include a printer. Same as the Peripherals Options dialog's Emulate printers option.

--rate frame
    Specify the frame rate, the ratio of spectrum frame updates to real frame updates. Same as the General Options dialog's Frame rate option.

-r file
--record file
    Specify an RZX file to begin recording to.

--separation
    Give stereo separation of the 128's AY sound channels. Same as the General Options dialog's AY stereo separation option.

--simpleide
    Specify whether Fuse will emulate the simple 8-bit IDE interface as used by the Spectrum +3e. Same as the Perpherals Option dialog's Simple 8-bit IDE option.

--simpleide-masterfile file
    Specify a HDF file to connect to the emulated Simple 8-bit IDE interface's master channel.

--simpleide-slavefile file
    Specify a HDF file to connect to the emulated Simple 8-bit IDE interface's slave channel.

--slt
    Support the SLT trap instruction. (Enabled by default, but you can use `--no-slt' to disable). Same as the General Options dialog's Use .slt traps option.

-s file
--snapshot file
    Specify a snapshot file to load. The file can be in any snapshot format supported by libspectrum(3).

--snaps-as-z80
    Specify whether the widget based user interfaces should save snapshots as .szx or .z80 files. The same as the General Options dialog's Save snaps as .z80 option.

--sound
    Specify whether Fuse should produce sound. (Enabled by default, but you can use `--no-sound' to disable). Same as the Sound Option dialog's Sound enabled option.

--sound-force-8bit
    Force the use of 8-bit sound, even if 16-bit is possible. Same as the Sound Option dialog's Force 8-bit option.

-d device
--sound-device device
    Specify the sound output device to use. Generally you shouldn't need to specify this, but it might be useful if you have more than one.

--speed percentage
    Specify the speed (as a percentage of real Spectrum speed) at which emulation should attempt to proceed. Same as the General Options dialog's Emulation speed option.

--statusbar
    For the GTK+ UI, enables the statusbar beneath the display. For the SDL UI, enables the status icons showing whether the disk and tape are being accessed. Same as the General Options dialog's Show statusbar option.

-v mode
--svgamode mode
    Specify which mode to use for the SVGAlib UI. Available values for mode are `320' (which corresponds to a 320x240x256 mode), the default and `640' (a 640x480x256 mode).

-t file
--tape file
    Specify a virtual tape file to use. It must be in TAP or TZX format.

--textfile file
    Set the filename used for text output from the emulated printers. See the PRINTER EMULATION section below for more details.

--traps
    Support traps for ROM tape loading/saving. (Enabled by default, but you can use `--no-traps' to disable). Same as the General Options dialog's Use tape traps option.

--trdosdisk file
    Insert the specified file into the emulated TR-DOS drive A: and select Pentagon mode on startup.

-V
--version
    Show which version of Fuse is being used.

--writable-roms
    Allow Spectrum programs to overwrite the ROM(s). The same as the General Options dialog's Allow writes to ROM option.

--zxatasp
    Specify whether Fuse emulate the ZXATASP interface. Same as the Perpherals Option dialog's ZXATASP interface option.

--zxatasp-upload
    Specify the state of the ZXATASP upload jumper. Same as the Perpherals Option dialog's ZXATASP upload option.

--zxatasp-write-protect
    Specify the state of the ZXATASP write protect jumper. Same as the Perpherals Option dialog's ZXATASP write protect option.

--zxatasp-masterfile file
    Specify a HDF file to connect to the emulated ZXATASP interface's master channel.

--zxatasp-slavefile file
    Specify a HDF file to connect to the emulated ZXATASP interface's slave channel.

--zxcf
    Specify whether Fuse emulate the ZXCF interface. Same as the Perpherals Option dialog's ZXCF interface option.

--zxcf-upload
    Specify the state of the ZXCF upload jumper. Same as the Perpherals Option dialog's ZXCF upload option.

--zxcf-cffile file
    Specify a HDF file to connect to the emulated ZXCF interface.

All long options which control on/off settings can be disabled using `--no-foo' (for an option `--foo'). For example, the opposite of `--issue2' is `--no-issue2'. These options can also be modified while the emulator is running, using the options dialogs - see the documentation for the Options menu in the MENUS AND KEYS section for details.

THE VARIOUS FRONT-ENDS
Fuse supports various front-ends, or UIs (user interfaces). The usual one is GTK+-based, but there are also SDL, Xlib, svgalib and framebuffer ones.

The important difference to note is that the GTK+ version uses `native' dialog boxes etc. (behaving like a fairly normal GUI-based program) while the others use an alternative, Fuse-specific `widget UI'. This latter front-end is easily spotted by the way it uses the main Fuse window/screen for menus and dialogs, and uses the Spectrum's own font.

MENUS AND KEYS
Since many of the keys available are devoted to emulation of the Spectrum's keyboard, the primary way of controlling Fuse itself (rather than the emulated machine) is via the menus. There are also function key shortcuts for some menu options.

In the GTK+ version, the menu bar is always visible at the top of the Fuse window. You can click on a menu name to pop it up. Alternatively, you can press F1 to display a pop-up version of the menu bar, which you can then navigate with the cursor keys or mouse.

In the widget UI pressing F1 is the only way to get the main menu; and unlike the GTK+ version, the emulator pauses while the menus are being navigated. The menus show which key to press for each menu option in brackets. Pressing Esc exits a menu, and pressing Enter exits the menu system entirely (as well as `confirming' any current dialog).

Here's what the menu options do, along with the function key mappings for those items which have them:

F3
File, Open...
    Open a Spectrum file. Snapshots will be loaded into memory; tape images will be inserted into the emulated tape deck, and if the Auto-load media option is set will being loading. Opening a disk image or a Timex dock image will cause the appropriate machine type (+3, Pentagon or TC2068) to be selected with the image inserted, and disks will automatically load if the Auto-load media option is set. See the FILE SELECTION section below for details on how to choose the file. Note that this behaviour is different from previous versions of Fuse, when this option would open only snapshots.

F2
File, Save Snapshot...
    Save a snapshot (machine state, memory contents, etc.) in Z80 format. The GTK+ UI lets you select a filename, but the others just write the file as either snapshot.szx or snapshot.z80 (depending on the state of the General Options dialog's Save snaps as .z80 option).

File, Recording, Record...
    Start recording input to an RZX file, initialised from the current emulation state. Again, the GTK+ UI lets you select a filename, while the others just write to record.rzx.

File, Recording, Record from snapshot...
    Start recording input to an RZX file, initialised from a snapshot. You will first be asked for the snapshot to use and then (under the GTK+ UI) for the file to save the recording to; the other UIs again write to record.rzx.

File, Recording, Play...
    Playback recorded input from an RZX file. This lets you replay keypresses recorded previously. RZX files generally contain a snapshot with the Spectrum's state at the start of the recording; if the selected RZX file doesn't, you'll be prompted for a snapshot to load as well.

File, Recording, Stop
    Stop any currently-recording/playing RZX file.

File, AY Logging, Record...
    Start recording the bytes output via the AY-3-8192 sound chip to a PSG file. The GTK+ UI lets you choose a filename, whilst the others will write to ay.psg.

File, AY Logging, Stop
    Stop any current AY logging.

File, Open SCR Screenshot...
    Load an SCR screenshot (essentially just a binary dump of the Spectrum's video memory) onto the current screen. Fuse supports screenshots saved in the Timex hi-colour and hi-res modes as well as `normal' Spectrum screens, and will make a simple conversion if a hi-colour or hi-res screenshot is loaded onto a non-Timex machine.

File, Save Screen as SCR...
    Save a copy of whatever's currently displayed on the Spectrum's screen as an SCR file. Once again, the GTK+ UI lets you choose a filename, while the others will just write to fuse.scr.

File, Save Screen as PNG...
    Save the current screen as a PNG file. The GTK+ UI lets you choose a filename, while the others will use fuse.png.

File, Load Binary Data...
    Load binary data from a file into the Spectrum's memory. After selecting the file to load data from, you can choose where to load the data and how much data to load.

File, Save Binary Data...
    Save an arbitrary chunk of the Spectrum's memory to a file. Select the file you wish to save to, followed by the location and length of data you wish to save.

F10
File, Exit
    Exit the emulator. If you're using the GTK+ UI, a confirmation dialog will appear checking you actually want to do this.

F4
Options, General...
    Display the General Options dialog, letting you configure Fuse. (With the widget UI, the keys shown in brackets toggle the options, Enter confirms any changes, and Esc aborts). Note that any changed settings only apply to the currently-running Fuse.

    The options available are:

    Emulation speed
        Set how fast Fuse will attempt to emulate the Spectrum, as a percentage of the speed at which the real machine runs. If your machine isn't fast enough to keep up with the requested speed, Fuse will just run as fast as it can. Note that if the emulation speed is not exactly 100%, no sound output will be produced.

    Frame rate
        Specify the frame rate, the ratio of spectrum frame updates to real frame updates. This is useful if your machine is having trouble keeping up with the spectrum screen updates.

    Issue 2 keyboard
        Early versions of the Spectrum used a different value for unused bits on the keyboard input ports, and a few games depended on the old value of these bits. Enabling this option switches to the old value, to let you run them.

    Use tape traps
        Ordinarily, Fuse intercepts calls to the ROM tape-loading routine in order to load from tape files more quickly when possible. But this can (rarely) interfere with TZX loading; disabling this option avoids the problem at the cost of slower (i.e. always real-time) tape-loading. When tape-loading traps are disabled, you need to start tape playback manually, by pressing F8 or choosing the Media, Tape, Play menu item.

    Auto-load media
        On many occasions when you open a tape or disk file, it's because it's got a program in you want to load and run. If this option is selected, this will automatically happen for you when you open one of these files. To use tapes or disks for saving data to, or for loading data into an already running program, you'll want to turn this option off.

    Save snaps as .z80
        Select the format used by the the widget based user interfaces for saving snapshots: they will be saved as .szx files if this option is disabled, or .z80 if this option is enabled. The .szx format is superior to .z80 both in terms of accuracy and hardware supported, and is therefore probably the better choice unless other concerns apply. Two situations you may wish to use .z80 are when giving snapshots to users of other emulators, as .szx is not well supported by other emulators, and when using .slt files, as these are not supported by the .szx format.

        This option has no effect on the GTK+ user interfaces.

    Use .slt traps
        The multi-load aspect of SLT files requires a trap instruction to be supported. This instruction is not generally used except for this trap, but since it's not inconceivable that a program could be wanting to use the real instruction instead, you can choose whether to support the trap or not.

    Allow writes to ROM
        If this option is selected, Fuse will happily allow programs to overwrite what would normally be ROM. This probably isn't very useful in most circumstances, especially as the 48K ROM overwrites parts of itself.

    Auto-save settings
        If this option is selected, Fuse will automatically write its currently selected options to its configuration file on exit (if libxml2 was available when Fuse was compiled). If you turn this option off, you'll have to manually use Options, Save afterwards to ensure that this setting gets written to Fuse's configuration file.

    Black and white TV
        This option allows you to choose whether to simulate a colour or black and white television. This is effective only under the GTK+ and SDL user interfaces: the others will always simulate a colour TV.

    Confirm actions
        Specify whether `dangerous' actions (those which could cause data loss, for example resetting the Spectrum) require confirmation before occuring. This option is effective only under the GTK+ UI.

    Show statusbar
        For the GTK+ UI, enables the statusbar beneath the display. For the SDL UI, enables the status icons showing whether the disk and tape are being accessed. This option has no effect for the other user interfaces.

Options, Sound...
    Display the Sound Options dialog, letting you configure Fuse's sound output. (With the widget UI, the keys shown in brackets toggle the options, Enter confirms any changes, and Esc aborts). Note that any changed settings only apply to the currently-running Fuse.

    Sound enabled
        Specify whether sound output should be enabled at all. When this option is disabled, Fuse will not make any sound.

    Loading sound
        Normally, Fuse emulates tape-loading noise when loading from TAPs or TZXs in real-time, albeit at a deliberately lower volume than on a real Spectrum. You can disable this option to eliminate the loading noise entirely.

    AY stereo separation
        By default, the sound output is mono, since this is all you got from an unmodified Spectrum. But enabling this option gives you so-called ACB stereo (for sound from the 128's AY-3-8912 sound chip). This actually works a little better than ACB stereo modifications for the machine itself, since it uses stereo positioning rather than simply playing on one channel only.

    Beeper pseudo-stereo
        The Spectrum beeper is inherently mono, but enabling this option adds a simple fake-stereo effect. While the slight echo involved can sometimes make beeper noise sound worse, in many cases it gives an acceptable result.

    Force 8-bit
        Force the use of 8-bit sound even if 16-bit (the default) is available. Note that (when the option is enabled) if 8-bit sound isn't available then there will be no sound at all, so it's best not to use this option unless you have a specific need for it.

Options, Peripherals...
    Display the Peripherals Options dialog, letting you configure the peripherals which Fuse will consider to be attached to the emulated machines. (With the widget UI, the keys shown in brackets toggle the options, Enter confirms any changes, and Esc aborts). Note that any changed settings only apply to the currently-running Fuse.

    Kempston joystick
        If this option is selected, Fuse will emulate a Kempston joystick interface (probably the most widely supported type on the Spectrum). Note that this option is basically equivalent to plugging the interface itself into a Spectrum, not to connecting a joystick; this affects how the Spectrum responds to a read of input port 31. To use a Kempston joystick in a game, this option must be enabled, and you must also select a Kempston joystick the Options, Joysticks menu.

    Interface II
        If this option is selected, Fuse will emulate a cartridge port as found on the Interface II. Cartridges can then be inserted and removed via the Media, Cartridge, Interface II menu. Note that the Pentagon, Scorpion, Interface II, ZXATASP and ZXCF all use the same hardware mechanism for accessing some of their extended features, so only one of these should be selected at once or unpredictable behaviour will occur.

    Emulate printers
        If this option is selected, Fuse will emulate a printer. See the PRINTER EMULATION section for more details.

    Simple 8-bit IDE
        If this option is selected, Fuse will emulate the simple 8-bit IDE interface as used by the Spectrum +3e, and allow hard disks to be connected and disconnected via the Media, IDE, Simple 8-bit menu.

    ZXATASP interface
        If this option is selected, Fuse will emulate the ZXATASP interface, which provides both additional RAM and an IDE interface. See the ZXATASP AND ZXCF section for more details.

    ZXATASP upload
        This option controls the state of the ZXATASP upload jumper. See the ZXATASP AND ZXCF section for more details.

    ZXATASP write protect
        This option controls the state of the ZXATASP write protect jumper. See the ZXATASP AND ZXCF section for more details.

    ZXCF interface
        If this option is selected, Fuse will emulate the ZXCF interface, which provides both additional RAM and a CompactFlash interface. See the ZXATASP AND ZXCF section for more details.

    ZXCF upload
        This option controls the state of the ZXCF upload jumper. See the ZXATASP AND ZXCF section for more details.

Options, RZX...
    Display the RZX Options dialog, letting you configure how Fuse's deals with RZX input recordings. (With the widget UI, the keys shown in brackets toggle the options, Enter confirms any changes, and Esc aborts). Note that any changed settings only apply to the currently-running Fuse.

    Compress RZX data
        If this option is selected, and zlib was available when Fuse was compiled, any RZX files written by Fuse will be compressed. This is generally a good thing as it makes the files significantly smaller, and you probably want to turn it off only if you're debugging the RZX files or there's some other program which doesn't support compressed RZX files.

    Competition mode
        Any input recordings which are started when this option is selected will be made in `competition mode'. In essence, this means that Fuse will act just like a real Spectrum would: you can't load snapshots, pause the emulation in any way, change the speed or anything that you couldn't do on the real machine. If any of these things are attempted, or if the emulated Fuse is running more than 5% faster or slower than normal Spectrum speed, then the recording will immediately be stopped.

        If libgcrypt was available when Fuse was compiled, then recordings made with competition mode active will be digitally signed, in theory to `certify' that it was made with the above restrictions in place. However, this procedure is not secure (and cannot be made so), so the presence of any signature on an RZX file should not be taken as providing proof that it was made with competition mode active. This feature is included in Fuse solely as it was one of the requirements for Fuse to be used in an on-line tournament.

    Competition code
        The numeric code entered here will be written into any RZX files made in competition mode. This is another feature for on-line tournaments which can be used to `prove' that the recording was made after a specific code was released. If you're not playing in such a tournament, you can safely ignore this option.

    Always embed snapshot
        Specify whether a snapshot should be embedded in an RZX file when recording is started from an existing snapshot.

Options, Joysticks
    Fuse can emulate many of the common types of joystick which were available for the Spectrum. The input for these emulated joysticks can be taken from real joysticks attached to the emulating machine (configured via the Options, Joysticks, Joystick 1... and Options, Joysticks, Joystick 2... options), or from the q, a, o, p, and Space keys on the emulating machines keyboard, configured via the Options, Joysticks, Keyboard... option. Note that when using the keyboard to emulate a joystick, the q, a, o, p, and Space keys will not have their normal effect (to avoid problems with games which do things like use p for pause when using a joystick).

    Each of the joysticks (including the `fake' keyboard joystick) can be configured to emulate any one of the following joystick types:

        None
            No joystick: any input will simply be ignored.

        Cursor
            A cursor joystick, equivalent to pressing 5 (left), 6 (down), 7 (up), 8 (right), and 0 (fire).

        Kempston
            A Kempston joystick, read from input port 31. Note that the Options, Peripherals, Kempston interface option must also be set for the input to be recognised.

        Sinclair 1
        Sinclair 2
            The `left' and `right' Sinclair joysticks, equivalent to pressing 1 (left), 2 (right), 3 (down), 4 (up), and 5 (fire), or 6 (left), 7 (right), 8 (down), 9 (up), and 0 (fire) respectively.

        Timex 1
        Timex 2
            The `left' and `right' joysticks as attached to the TC2068's built-in joystick interface.

    For the real joysticks, it is also possible to configure (although currently only when using the GTK+ interface) what effect each button on the joystick will have: this can be Joystick Fire, equivalent to presing the emulated joystick's fire button, Nothing, meaning to have no effect, or any Spectrum key, meaning that pressing that button will be equivalent to pressing that Spectrum key.

Options, Select ROMs
    An individual dialog is available for each Spectrum variant emulated by Fuse which allows selection of the ROM(s) used by that machine. Simply select the ROM you wish to use, and then reset the Spectrum for the change to take effect.

Options, Filter...
    Select the graphics filter currently in use. See the GRAPHICS FILTERS section for more details.

Options, Save
    If libxml2 was available when Fuse was compiled, this will cause Fuse's current options to be written to .fuserc in your home directory, from which they will be picked up again when Fuse is restarted. The best way to update this file is by using this option, but it's a simple XML file and shouldn't be too hard to edit by hand if you really want to.

Pause
Machine, Pause
    Pause or unpause emulation. This option is available only under the GTK+ UI; to pause the other user interfaces, simply press F1 to bring up the main menu.

F5
Machine, Reset
    Reset the emulated Spectrum. Again, you get a chance to cancel this if you're using the GTK+ UI.

F9
Machine, Select...
    Choose a type of Spectrum to emulate. An brief overview of the Sinclair, Amstrad and Timex can be found at http://www.nvg.ntnu.no/sinclair/computers/zxspectrum/zxspectrum.htm, while more technical information can be found at http://www.worldofspectrum.org/faq/reference/reference.htm.

    Spectrum 16K
    Spectrum 48K
        The original machines as released by Sinclair in 1982 with 16 or 48K of RAM respectively.

    Spectrum 128K
        The 128K machine as released by Sinclair in 1985 (Spain) or 1986 (UK).

    Spectrum +2
        The first machine released by Amstrad, in 1986. From an emulation point of view, the +2 is virtually identical to the 128K.

    Spectrum +2A
    Spectrum +3
        The two machines released by Amstrad in 1988. Technically very similar to each other, except that the +3 features a 3" disk drive while the +2A does not.

    Spectrum +3e
        A +3 with modified ROMs allowing access to IDE hard disks via the simple 8-bit interface, as activated from the Options, Peripherals dialog. See http://www.zxplus3e.plus.com/ for more details.

    Timex TC2048
    Timex TC2068
        The variants of the Spectrum as released by Timex in Portugal. See http://www.worldofspectrum.org/faq/reference/tmxreference.htm for more details.

    Pentagon 128K
    Scorpion ZS 256
        Two Russian clones of the Spectrum. Some details can be found at http://www.worldofspectrum.org/rusfaq/index.html, but possibly the most important thing to note about both these machines is that they have built in 3.5" disk drives, accessed via the Betadisk interface and TR-DOS (the Technology Research Disk Operating System).

    Spectrum SE
        A recent variant designed by Andrew Owen and Jarek Adamski, which is possibly best thought of as a cross between the 128K machine and the Timex variants, allowing 272K of RAM to be accessed. Some more details are available at http://www.worldofspectrum.org/faq/reference/sereference.htm.

Machine, Debugger...
    Start the monitor/debugger. See the MONITOR/DEBUGGER section for more information.

Machine, Poke Finder...
    Start the `poke finder' (available only under the GTK+ UI). See the POKE FINDER section for more information.

Machine, Memory Browser...
    Start the memory browser (again available only under the GTK+ UI). It should be fairly obvious what this does; perhaps the only thing worth noting is that emulation is paused until you close the window.

Machine, NMI
    Sends a non-maskable interrupt to the emulated Spectrum. Due to a typo in the standard 48K ROM, this will cause a reset, but modified ROMs are available which make use of this feature.

F7
Media, Tape, Open...
    Choose a TAP or TZX virtual-tape file to load from. See the FILE SELECTION section below for details on how to choose the file. If Auto-load media is set in the General Options dialog (as it is by default), the tape will begin loading. Otherwise, you have to start the load in the emulated machine (with LOAD "" or the 128's Tape Loader option, though you may need to reset first).

    To guarantee that TZX files will load properly, you should select the file, make sure tape-loading traps are disabled in the General Options dialog, then press F8 (or do Media, Tape, Play). That said, most TZXs will work with tape-loading traps enabled (often quickly loading partway, then loading the rest real-time), so you might want to try it that way first.

F8
Media, Tape, Play
    Start playing the TAP or TZX file, if required. (Choosing the option (or pressing F8) again pauses playback, and a further press resumes). To explain - if tape-loading traps have been disabled (in the General Options dialog), starting the loading process in the emulated machine isn't enough. You also have to `press play', so to speak :-), and this is how you do that. You may also need to `press play' like this in certain other circumstances, e.g. TZXs containing multi-load games may have a stop-the-tape request (which Fuse obeys).

Media, Tape, Browse
    Browse through the current tape. A brief display of each of the data blocks on the current tape will appear, from which you can select which block Fuse will play next. With the GTK+ UI, emulation will continue while the browser is displayed; double-clicking on a block will select it. In the other UIs, emulation is paused and you can use the cursor keys and press Enter to select it. If you decide you don't want to change block, just press Escape.

Media, Tape, Rewind
    Rewind the current virtual tape, so it can be read again from the beginning.

Media, Tape, Clear
    Clear the current virtual tape. This is particularly useful when you want a `clean slate' to add newly-saved files to, before doing Media, Tape, Write... (or F6).

F6
Media, Tape, Write...
    Write the current virtual-tape contents to a TZX file. The GTK+ UI lets you select a filename (see FILE SELECTION below), the others just write the file as tape.tzx, and have a slightly different menu item. The virtual-tape contents are the contents of the previously-loaded tape (if any has been loaded since you last did a Media, Tape, Clear), followed by anything you've saved from the emulated machine since. These newly-saved files are not written to any tape file until you choose this option!

Media, Disk
    Virtual disk images are only accessible when emulating a +3, Pentagon or Scorpion. If any of the disk options are selected while emulating a +3, they refer to the +3's disk drives, which are both of the 3 With the usual +3 format, these have a capacity of 173K. If the Pentagon or Scorpion is being emulated, these options refer to the TR-DOS disk drives. If any other machine is being emulated, this menu cannot be selected. (See THE .DSK FORMAT and TR-DOS DISK FORMATS sections below for notes on the file formats supported).

    Note that (since version 0.6.2), Fuse works with true virtual disk images: any changes made to a disk image will not affect the file which was `inserted' into the drive. If you do want to keep any changes, use the appropriate `eject and write' option before exiting Fuse.

Media, Disk, Drive A:, Insert...
    Select a disk-image file to read/write in the emulated drive A:.

Media, Disk, Drive A:, Eject
    Deselect the disk image currently in drive A: - or from the emulated machine's perspective, eject it. Note that any changes made to the image will not be saved.

Media, Disk, Drive A:, Eject and write...
    Deselect the disk image currently in drive A: and write the current state of the disk to a file. The GTK+ UI lets you select a filename, while the others will write +3 disk images to `drivea.dsk' or Pentagon disk images to `drivea.trd'.

Media, Disk, Drive B:, Insert...
    As above, but for drive B:.

Media, Disk, Drive B:, Eject
    As above, but for drive B:.

Media, Disk, Drive B:, Eject and write
    As above, but for drive B:. The filenames used by the widget-based UIs are `driveb.dsk' and `driveb.trd' respectively.

Media, Cartridge, Timex Dock, Insert...
    Insert a cartridge into the TC2068's dock. This will cause the emulated machine to be changed to the TC2068 (if it wasn't already) and reset.

Media, Cartridge, Timex Dock, Eject
    Remove the cartridge from the TC2068's dock. This will cause the emulated machine to be reset.

Media, Cartridge, Interface II, Insert...
    Insert a cartridge into the Interface II cartridge slot. This will cause the emulated machine to be reset and the cartridge loaded.

Media, Cartridge, Interface II, Eject...
    Remove the cartridge from the Interface II cartridge slot. This will cause the emulated machine to be reset.

Media, IDE, Simple 8-bit, Master, Insert...
    Connect an IDE hard disk to the simple 8-bit interface's master channel.

Media, IDE, Simple 8-bit, Master, Commit
    Cause any writes which have been done to virtual hard disk attached to the simple 8-bit interface's master channel to be committed to the real disk, such that they survive the virtual disk being ejected.

Media, IDE, Simple 8-bit, Master, Eject
    Eject the virtual hard disk from the simple 8-bit interface's master channel. Note that any writes to the virtual hard disk will be lost unless the Media, IDE, Simple 8-bit, Master, Commit option is used before the disk is ejected.

Media, IDE, Simple 8-bit, Slave, Insert...
Media, IDE, Simple 8-bit, Slave, Commit
Media, IDE, Simple 8-bit, Slave, Eject
    The same as the Media, IDE, Simple 8-bit, Master entries above, but for the simple 8-bit interface's slave channel.

Media, IDE, ZXATASP, Master, Insert...
Media, IDE, ZXATASP, Master, Commit
Media, IDE, ZXATASP, Master, Eject
Media, IDE, ZXATASP, Slave, Insert...
Media, IDE, ZXATASP, Slave, Commit
Media, IDE, ZXATASP, Slave, Eject
    The same as the Media, IDE, Simple 8-bit, Master entries above, but for the two channels of the ZXATASP interface.

Media, IDE, ZXCF CompactFlash, Insert...
Media, IDE, ZXCF CompactFlash, Commit
Media, IDE, ZXCF CompactFlash, Eject
    The same as the Media, IDE, Simple 8-bit, Master entries above, but for the ZXCF interface's CompactFlash slot.

Help, Keyboard picture...
    Display a diagram showing the Spectrum keyboard, and the various keywords that can be generated with each key from (48K) BASIC. Under the GTK+ UI, this will appear in a separate window and emulation continues. With the other UIs, the picture remains onscreen (and the emulator paused) until you press Esc or Enter.

KEY MAPPINGS
When emulating the Spectrum, keys F1 to F10 are used as shortcuts for various menu items, as described above. The alphanumeric keys (along with Enter and Space) are mapped as-is to the Spectrum keys. The other key mappings are:

Shift
    emulated as Caps Shift

Control, Alt, and Meta
    emulated as Symbol Shift (most other modifiers are also mapped to this)

Backspace
    emulated as Caps-0 (Delete)

Esc emulated as Caps-1 (Edit)

Caps Lock
    emulated as Caps-2

Cursor keys
    emulated as Caps-5/6/7/8 (as appropriate)

Tab emulated as Caps Shift-Symbol Shift (Extended Mode)

Some further punctuation keys are supported, if they exist on your keyboard - `,', `.', `/', `;', `'', `#', `-', and `='. These are mapped to the appropriate symbol-shifted keys on the Spectrum.

A list of keys applicable when using the file selection dialogs is given in the FILE SELECTION section below.

DISPLAY SIZE
Some of Fuse's UIs allow resizing of the emulated Spectrum's display. For the window-based ones (GTK+ and Xlib), you can resize the window by, well, resizing it. :-) Exactly how this works depends on your window manager; you may have to make the window over twice the width and height of the original size before it actually scales up. Fuse attempts to keep the window 'square', but with some window managers this can mean the window will never resize at all. If you experience this problem, the `--no-aspect-hint' option may help.

If you're using the SDL UI under X11, the window will automatically resize to be the correct size for the graphics filter selected.

GRAPHICS FILTERS
Fuse has the ability to apply essentially arbitrary filters between building its image of the Spectrum's screen, and displaying it on the emulating machine's monitor. These filters can be used to do various forms of smoothing, emulation of TV scanlines and various other possibilities. Support for graphics filters varies between the different user interfaces, but there are two general classes: the GTK+ and SDL user interfaces (and the saving of .png screenshots) support `interpolating' filters which use a palette larger than the Spectrum's 16 colours, while the Xlib and SVGAlib user interfaces support only `non-interpolating' filters. The framebuffer user interface currently does not support filters at all.

A further complication arises due to the fact that the Timex machines have their high-resolution video mode with twice the horizontal resolution. To deal with this, Fuse treats these machines as having a `normal' display size which is twice the size of a normal Spectrum's screen, leading to a different set of filters being available for these machines. Note that any of the double or triple-sizing filters are available for Timex machines only when using the SDL user interface.

The available filters, along with their short name used to select them from the command line, are:

Timex half (smoothed) (half)
Timex half (skipping) (halfskip)
    Two Timex-machine specific filters which scale the screen down to half normal (Timex) size; that is, the same size as a normal Spectrum screen. The difference between these two filters is in how they handle the high-resolution mode: the `smoothed' version is an interpolating filter which averages pairs of adjacent pixels, while the `skipping' version is a non-interpolating filter which simply drops every other pixel.

Normal (normal)
    The simplest filter: just display one pixel for every pixel on the Spectrum's screen.

Double size (2x)
    Scale the displayed screen up to double size.

Triple size (3x)
    Scale the displayed screen up to triple size. Available only with the GTK+ and SDL user interfaces or when saving screenshots of non-Timex machines.

2xSaI (2xsai)
Super 2xSaI (super2xsai)
SuperEagle (supereagle)
    Three interpolating filters which apply successively more smoothing. All three double the size of the displayed screen.

AdvMAME2x (advmame2x)
    A double-sizing, non-interpolating filter which attempts to smooth diagonal lines.

AdvMAME3x (advmame3x)
    Very similar to AdvMAME2x, except that it triples the size of the displayed screen. Available only with the GTK+ and SDL user interfaces or when saving screenshots of non-Timex machines.

TV 2x (tv2x)
Timex TV (timextv)
    Two filters which attempt to emulate the effect of television scanlines. The former is a double-sizing filter for non-Timex machines, while the latter is a single-sizing filter for Timex machines (note that this means both produce the same size output).

Dot matrix (dotmatrix)
    A double-sizing filter which emulates the effect of a dot-matrix display.

Timex 1.5x (timex15x)
    An interpolating Timex-specific filter which scales the Timex screen up to 1.5x its usual size (which is therefore 3x the size of a `normal' Spectrum screen). Available only for the GTK+ and SDL user interfaces or when saving screenshots.

THE EMULATED SPECTRUM
The emulated Spectrum is, by default, an unmodified 48K Spectrum with a tape player and ZX Printer attached. Oh, and apparently some magical snapshot load/save machine which is probably best glossed over for the sake of the analogy. :-)

To emulate different kinds of Spectrum, select the Machine, Select... menu option, or press F9.

The Spectrum emulation is paused when any dialogs appear. In the widget UI, it's also paused when menus or the keyboard picture are displayed.

PRINTER EMULATION
The various models of Spectrum supported a range of ways to connect printers, three of which are supported by Fuse. Different printers are made available for the different models:

16, 48, TC2048, TC2068
    ZX Printer

128/+2/Pentagon
    Serial printer (text-only)

+2A, +3
    Parallel printer (text-only)

Any printout is appended to one (or both) of two files, depending on the printer - these default to printout.txt for text output, and printout.pbm for graphics (PBM images are supported by most image viewers and converters). These names can be changed with the --textfile and --graphicsfile options from the command line or configuration file. While the ZX Printer can only output graphically, simulated text output is generated at the same time using a crude sort of OCR based on the current character set (a bit like using SCREEN$). There is currently no support for graphics when using the serial/parallel output, though any escape codes used will be `printed' faithfully. (!)

By the way, it's not a good idea to modify the printout.pbm file outside of Fuse if you want to continue appending to it. The header needs to have a certain layout for Fuse to be able to continue appending to it correctly, and the file will be overwritten if it can't be appended to.

ZXATASP AND ZXCF
The ZXATASP and ZXCF interfaces are two peripherals designed by Sami Vehmaa which significantly extend the capabilities of the Spectrum. More details on both are available from Sami's homepage, http://user.tninet.se/~vjz762w/, but a brief overview is given here.

The real ZXATASP comes with either 128K or 512K of RAM and the ability to connect an IDE hard disks and a CompactFlash card, while the ZXCF comes with 128K, 512K or 1024K of RAM and the ability to connect a CompactFlash card. From an emulation point of view, the two interfaces are actually very similar as a CompactFlash card is logically just an IDE hard disk. Currently, Fuse's emulation is fixed at having 512K of RAM in the ZXATASP and 1024K in the ZXCF.

To activate the ZXATASP, simply select the ZXATASP interface option from the Options, Peripherals... dialog. The state of the upload and write protect jumpers is then controlled by the ZXATASP upload and ZXATASP write protect options. Similarly, the ZXCF is controlled by the ZXCF interface and ZXCF upload options (the ZXCF write protect is software controlled).

If you're using either the ZXATASP or ZXCF, you almost certainly want to investigate ResiDOS, the operating system designed for use with the ZXATASP and ZXCF. ResiDOS provides facilities for using the extra RAM, accessing the mass storage devices and a task manager allowing virtually instant switching between programs on the Spectrum. See http://www.zxplus3e.plus.com/residos/index.html for more details.

FILE SELECTION
The way you select a file (whether snapshot or tape file) depends on which UI you're using. So firstly, here's how to use the GTK+ file selector.

The selector shows the directories and files in the current directory in two separate subwindows. If either list is too big to fit in the window, you can use the scrollbar to see the rest (by dragging the slider, for example), or you can use Shift-Tab (to move the keyboard focus to a subwindow) and use the cursor keys. To change directory, double-click it.

To choose a file to load you can either double-click it, or click it then click Ok. Or click Cancel to abort.

If you're using the keyboard, probably the easiest way to use the selector is to just ignore it and type in the name. This isn't as irksome as it sounds, since the filename input box has filename completion - type part of a directory or file name, then press Tab. It should complete it. If it was a directory, it moves to that directory; if the completion was ambiguous, it completes as much as possible, and narrows the filenames shown to those which match. You should press Enter when you've finished typing the filename, or Esc to abort.

Now, if you're using the widget UI - the one using the Spectrum font - the selector works a bit differently. The files and directories are all listed in a single two-column-wide window (the directories are shown at the top, ending in `/') - the names may be truncated onscreen if they're too long to fit.

To move the cursor, you can either use the cursor keys, or the Spectrum equivalents 5/6/7/8, or (similarly) h/j/k/l. For faster movement, the Page Up, Page Down, Home, and End keys are supported and do what you'd expect. To select a file or directory, press Enter. To abort, press Esc.

With both selectors, do bear in mind that all files are shown, whether Fuse would be able to load them or not.

MONITOR/DEBUGGER

Firstly, note that the vast majority of this section applies only if you're using the GTK+ user interface; if you're using one of the widget user interfaces, you'll get a very basic monitor which shows the current values of the registers and allows you to single step through execution or continue.

If you are using the GTK+ user interface, Fuse features a moderately powerful, completely transparent monitor/debugger, which can be activated via the Machine, Debugger ... menu option. A debugger window will appear, showing the current state of the emulated machine: the top-left `pane' shows the current state of the Z80 and the last bytes written to any emulated peripherals. The bottom-left pane lists any active breakpoints. Moving right, the next pane shows where the Spectrum's 64K memory map (the `W?' and `C?' indicate whether each 8K chunk is writable or contended respectively), and the next a disassembly, which by default starts at the current program counter, although this can be modified either by the `disassemble' command (see below) or by dragging the scrollbar next to it. The next pane shows the current stack, and the final pane any `events' which are due to occur and could affect emulation. Any of these panes can be removed by use of the View menu. Below the displays are an entry box for debugger commands, and five buttons for controlling the debugger:

Evaluate
    Evaluate the command currently in the entry box.

Single Step
    Run precisely one Z80 opcode and then stop emulation again.

Continue
    Restart emulation, but leave the debugger window open. Note that the debugger window will not be updated while emulation is running.

Break
    Stop emulation and return to the debugger.

Close
    Close the debugger window and restart emulation.

Double-clicking on an entry in the stack pane will cause emulation to run until the program counter reaches the value stored at that address, while double-clicking on an entry in the `events' pane will cause emulation to run until that time is reached.

The main power of the debugger is via the commands entered into the entry box, which are similar in nature (but definitely not identical to or as powerful as) to those in gdb(1). In general, the debugger is case-insensitive, and numbers will be interpreted as decimal, unless prefixed by either `0x' or `$' when they will be interpreted as hex. Each command can be abbreviated to the portion not in curly braces.

ba{se} number
    Change the debugger window to displaying output in base number. Available values are 10 (decimal) or 16 (hex).

br{eakpoint} [address] [condition]
    Set a breakpoint to stop emulation and return to the debugger whenever an opcode is executed at address and condition evaluates true. If address is omitted, it defaults to the current value of PC.

br{eakpoint} p{ort} (r{ead}|w{rite}) port [condition]
    Set a breakpoint to trigger whenever IO port port is read from or written to and condition evaluates true.

br{eakpoint} (r{ead}|w{rite}) [address] [condition]
    Set a breakpoint to trigger whenever memory location address is read from (other than via an opcode fetch) or written to and condition evaluates true. Address again defaults to the current value of PC if omitted.

br{eakpoint} ti{me} time [condition]
    Set a breakpoint to occur time tstates after the start of the current frame, assuming condition evaluates true (if one is given).

cl{ear} [address]
    Remove all breakpoints at address or the current value of PC if address is omitted. Port read/write breakpoints are unaffected.

cond{ition} id [condition]
    Set breakpoint id to trigger only when condition is true, or unconditionally if condition is omitted.

co{ntinue}
    Equivalent to the Continue button.

del{ete} [id]
    Remove breakpoint id, or all breakpoints if id is omitted.

di{sassemble} address
    Set the centre panel disassembly to begin at address.

fi{nish}
    Exit from the current CALL or equivalent. This isn't infallible: it works by setting a temporary breakpoint at the current contents of the stack pointer, so will not function correctly if the code returns to some other point or plays with its stack in other ways. Also, setting this breakpoint doesn't disable other breakpoints, which may trigger before this one. In that case, the temporary breakpoint remains, and the `continue' command can be used to return to it.

i{gnore} id count
    Do not trigger the next count times that breakpoint id would have triggered.

n{ext}
    Step to the opcode following the current one. As with the `finish' command, this works by setting a temporary breakpoint at the next opcode, so is not infalliable.

o{ut} port value
    Write value to IO port port.

se{t} address value
    Poke value into memory at address.

se{t} register value
    Set the value of the Z80 register register to value.

s{tep}
    Equivalent to the Single Step button.

t{breakpoint} [options]
    This is the same as the `breakpoint' command in its various forms, except that that breakpoint is temporary: it will trigger once and once only, and then be removed.

Addresses can be specified in one of two forms: either an absolute addresses, specifed by an integer in the range 0x0000 to 0xFFFF or as a `page:offset' combination, which refers to a location offset bytes into into memory bank page, independent of where that bank is currently paged into memory. RAM pages are indicated simply by an integer, while ROMs are prefixed by `R' (eg offset 0x1234 in ROM 1 is specified as `R1:0x1234'). Pages selected via the /ROMCS line are prefixed with `C', while the Timex Dock and Exrom use prefixes `D' and `X' respectively. The 48K machines are treated as having a permanent mapping of page 5 at 0x4000, page 2 at 0x8000 and page 0 at 0xC000; the 16K Spectrum is treated as having page 5 at 0x4000 and no page at 0x8000 and 0xC000.

Anywhere the debugger is expecting a numeric value, except where it expects a breakpoint id, you can instead use a numeric expression, which uses a restricted version of C's syntax; exactly the same syntax is used for conditional breakpoints, with `0' being false and any other value being true. In numeric expressions, you can use integer constants (all calculations is done in integers), register names (which simply evaluate to the value of the register), parentheses, the standard four numeric operations (`+', `-', `*' and `/'), the (non-)equality operators `==' and `!=', the comparision operators `>', `<', `>=' and `<=', bitwise and (`&'), or (`|') and exclusive or (`^') and logical and (`&&') and or (`||').

THE POKE FINDER

The `poke finder', available only under the GTK+ UI, is a tool which is designed to make the task of finding (infinite lives etc) pokes for games a bit easier: it is similar to the `Lifeguard' utility which was available for use with the Multiface. It works by maintaining a list of locations in which the current number of lives (etc) may be stored, and having the ability to remove from that list any locations which don't contain a specified value.

The poke finder dialog contains an entry box for specifying the value to be searched for, a count of the current number of possible locations and, if there are less than 20 possible locations, a list of the possible locations (in `page:offset' format). The five buttons act as follows:

Incremented
    Remove from the list of possible locations all addresses which have not been incremented since the last search.
Decremented
    Remove from the list of possible locations all addresses which have not been decremented since the last search.

Search
    Remove from the list of possible locations all addresses which do not contain the value specified in the `Search for' field.

Reset
    Reset the poke finder so that all locations are considered possible.

Close
    Close the dialog. Note that this does not reset the current state of the poke finder.

Double-clicking on an entry in the list of possible locations will cause a breakpoint to be set to trigger whenever that location is written to.

An example of how to use this may make things a bit clearer. We'll use the 128K version of Gryzor. Load the game, define keys to suit and start playing. Immediately pause the game and bring up the poke finder dialog. We note that we currently have 6 lives, so enter `6' into the `Search for' field and click `Search'. This reduces the number of possible locations to around 931 (you may get a slightly different number depending on exactly when you paused the game). Play along a bit and then (deliberately) lose a life. Pause the game again. As we now have 5 lives, replace the `6' in the 'Search for' field with a `5' and click `Search' again. This then reduces the list of possible locations to just one: page 2, offset 0x00BC. This is the only location in memory which stored `6' when we had 6 lives and `5' when we had 5 lives, so its pretty likely that this is where the lives count is stored. Double-clicking on the `2:0x00BC' entry in the dialog will set the appropriate breakpoint (you may wish to open the debugger at this point to confirm this). Play along a bit more. When you next lose a life, emulation is stopped with PC at 0x91CD. Scrolling up a few addresses in the debugger's disassembly pane shows a value was loaded from 0x80BC (our hypothetical lives counter), decremented and then stored again to 0x80BC, which looks very much like the code to reduce the number of lives. We can now use the debugger to replace the decrement with a NOP (`set 0x91c9 0'), and playing the game some more after this reveals that this has worked and we now have infinite lives.

THE .DSK FORMAT

In general, disk images for the +3 Spectrum are thought of as being in DSK format. However, this is actually an slight oversimplification; there in in fact two similar, but not identical, DSK formats. (The difference can be seen by doing `head -1 dskfile': one format will start `MV - CPCEMU' and the other will start `EXTENDED').

The `lib765' library used by Fuse to emulate the +3's FDC supports the `CPCEMU' format, but not the extended format. If the `libdsk' library was also found while compiling Fuse, this is used to provide support for the extended format, as well as for other goodies such as compressed disk images.

TR-DOS DISK FORMATS

Fuse supports .SCL and .TRD images in its Pentagon and Scorpion emulation; truncated .TRD files need to be expanded with another utility before use with Fuse.

COMPRESSED FILES

Assuming the appropriate libraries were available when libspectrum(3) was compiled, snapshots, tape images, dock cartridges and input recording files can be read from files compressed with bzip2(3) or gzip(3) just as if they were uncompressed. libdsk provides an equivalent functionality for +3 disk images if available, but there is currently no support for reading compressed TR-DOS disk images.

BUGS
Selecting a startup filter doesn't work properly with user interfaces other than SDL.

Attempting to replay an RZX file without an embedded snapshot from the command-line doesn't work if you do `./fuse rzxfile snapshot'. `./fuse snapshot rzxfile' does work though, so use that instead.

Changing virtual consoles when using SVGAlib for joystick support causes Fuse to exit. If this is a problem, compile Fuse with the `--disable-ui-joystick' option.

The poke finder can't search outside `normal' RAM.

Using the Options, Joysticks, Joystick 1... or Options, Joysticks, Joystick 2... options under GTK+ 2.x produces a large number of GTK+ critical warnings. This is a GTK+ bug (#144427), which is fixed in GTK+ 2.4.4.

FILES
~/.fuserc

SEE ALSO
bzip2(3), fuse-utils(1), gzip(3), libspectrum(3), xspect(1), xzx(1)

The comp.sys.sinclair Spectrum FAQ, at
http://www.worldofspectrum.org/faq/index.html.

AUTHOR
Philip Kendall (pak21-fuse@srcf.ucam.org).

Matan Ziv-Av wrote the svgalib and framebuffer UIs, the glib replacement code, and did some work on the OSS-specific sound code and the original widget UI code.

Russell Marks wrote the sound emulation and OSS-specific sound code, the joystick emulation, some of the printer code, and the original version of this man page.

John Elliott's lib765 library emulates the +3's disk controller chip, providing Fuse's +3 disk support, and his libdsk library provides support for more disk image formats.

Ian Collier wrote the ZX Printer emulation (for xz80).

Darren Salt wrote the original versions of the code for +3 emulation, SLT support, MITSHM support (for the Xlib UI), TZX raw data blocks, and RZX embedded snapshots and compression.

Alexander Yurchenko wrote the OpenBSD/Solaris-specific sound code.

Fredrick Meunier wrote the TC2048, Pentagon and Spectrum SE support as well as maintaining the OS X port and importing the graphics filter code.

Ludvig Strigeus and The ScummVM project wrote the original graphics filter code.

Dmitry Sanarin wrote the original TR-DOS emulation (for Glukalka).

Witold Filipczyk wrote the TC2068 support.

Matthew Westcott wrote the AY logging code.

Marek Januszewski wrote various bits of code to make Fuse work under Win32, including the DirectDraw user interface.

Stuart Brady wrote the Scorpion emulation and the HP-UX sound code.

Garry Lancaster wrote the 8-bit IDE, ZXATASP and ZXCF interface emulations.