Network SID Device

Implementation of a network SID device protocol

You can implement your own SID device (hardware or software-based) and control it using JSIDPlay2. The network SID device protocol has been defined to communicate with these implementations.

This protocol is called: Network SID device protocol. Communication is done via socket connection and port 6581 by default.

JSIDPlay2 can act as a client or as a server:

  1. JSIDPlay2 is able to use these SID implementations as a client to play back SID on these devices.

  2. JSIDPlay2 also provides such a device (Network SID Device) implementing the network SID device protocol to be used with other software (e.g., ACID64)

The shared API description below is reproduced verbatim from Wilfred Bos’s published specification (Git blob 95e50ae4a7ec5aacbaf1c13c8f1efd8f0ad43929). Keep its wording in sync with that source. JSIDPlay2/JSIDDevice details and clarifications of ambiguous upstream wording are documented separately under Developer notes; they are not changes to the shared text.

General Overview

Since version 2, the protocol is structured as a request-response protocol:

  • Requests are variable length, with a minimum packet size 4 bytes. There are three fields and an amorphous data blob:

    • 8-bit unsigned as command.

    • 8-bit unsigned as SID number.

    • 16-bit unsigned as the length of data attached to the header in bytes.

    • Data (if any).

  • All multibyte integer values are transmitted in big-endian order (most significant byte first).

  • All commands are ACKed with a response packet. The first byte is an 8-bit unsigned response code identifying one of the following forms:

    • OK (0) means that the commands were accepted by the server and can be discarded by the client. No data will be appended to response.

    • BUSY (1) means that no part of the current command was accepted because the playback queue cannot accept more data or the command must wait for audio to become quiescent. The client should wait and retry the command. One millisecond could be a suitable delay before retry. Queue length is limited both by the number of events and the maximum time drift between playback clock and client clock. No data is appended to the response.

    • ERROR (2): the request failed. The remaining response bytes, if any, contain the error message as an ISO-8859-1 encoded string.

    • READ (3): successful read operation, one byte value follows that is the value read from the addressed device.

    • VERSION (4): response to GET_VERSION operation. Version number will be appended to the response.

    • COUNT (5): number of SID configurations supported by network device.

    • INFO (6): info packet containing a model code and an ISO-8859-1 encoded model name of up to 255 bytes.

  • The maximum packet length is 65,539 bytes, including the four-byte header. It is suggested that only short packets are transmitted, in the order of 1KB and containing no more than about 1 ms worth of events. Otherwise, the client-server desync brings jitter that may have unpleasant consequences. At the limit it’s possible to simply send a single write event in each packet, but this is probably measurably less efficient.

Protocol version information

  • Version 1

    • It contains commands FLUSH, TRY_SET_SID_COUNT, MUTE, TRY_RESET, TRY_DELAY, TRY_WRITE, TRY_READ and GET_VERSION. There are eight SID devices where bit 0 sets 6581/8580, bit 1 sets PAL/NTSC and bit 2 sets RESAMPLE/DECIMATE mode of operation.

  • Version 2

    • It contains commands TRY_SET_SAMPLING, SET_CLOCKING, GET_CONFIG_COUNT, GET_CONFIG_INFO, SET_SID_POSITION, SET_SID_LEVEL, SET_SID_MODEL. There are multiple SID devices of type 6581 and 8580. The commands TRY_SET_SAMPLING and SET_CLOCKING configure sampling and clocking for all SID devices.

  • Version 3

    • supports muting of voice number 4 (digi channel).

  • Version 4

    • contains commands SET_DELAY, SET_FADE_IN, SET_FADE_OUT and SET_SID_HEADER.

  • Version 5

    • contains commands TRY_WRITE_EX, TRY_READ_EX, TRY_SET_FM_OPL.

Error handling

  • unknown commands return ERROR.

  • commands with invalid data values or an incorrect data length, including missing required data, return ERROR.

  • errors are reported using the ERROR (2) response defined in General Overview.

  • the optional error message is intended for display or diagnostics. Clients must not depend on its presence or exact wording.

  • additional error conditions are described under the individual commands.

  • response descriptions under individual commands assume valid requests.

Command Overview

  • The structure of data is specific to command. Some commands require data, others will not use data even if such was provided. Some commands require specific lengths for the data packets. Known commands are identified by small integers, starting from 0:

    • FLUSH (0): destroy queued data on all SIDs and FM OPL and cease audio production.

      • sid number is ignored.

      • data packet must be 0 length.

      • should probably be followed by TRY_RESET (SID is in unpredictable state).

      • always returns OK.

    • TRY_SET_SID_COUNT (1): set the number of SID devices available for writing

      • sid number equals the count of SIDs wanted.

      • data packet must be 0 length.

      • returns BUSY until audio quiescent, otherwise OK.

    • MUTE (2): mute/unmute a voice on specified SID

      • the data packet must contain two 8-bit unsigned bytes:

        • the voice number from 0 to 3. Voice number 3 (digi) is supported since version 3. Version 2 supports only voice numbers 0 to 2.

        • Zero or one to disable/enable voice.

      • this command bypasses the buffer and takes immediate effect.

      • always returns OK.

    • TRY_RESET (3): reset all SIDs and the enabled FM OPL device.

      • the data packet must contain one 8-bit unsigned value written to the volume register of each SID.

      • if FM OPL is enabled, it is reset to its initial state. The volume value does not apply to FM OPL.

      • returns BUSY until audio quiescent, otherwise OK.

    • TRY_DELAY (4): inform emulation that no events have occurred for a given count of cycles

      • the data packet must be a 16-bit unsigned value interpreted as a delay in C64 clocks. 0 is not allowed.

      • it allows audio generation in the absence of other activity.

      • returns BUSY if there is already enough data for playback, otherwise OK.

    • TRY_WRITE (5): try to queue a number of write-to-sid events for up to 8 SID chips.

      • data packet must be 4*N bytes long, repeating this structure:

        • 16-bit unsigned value interpreted as delay before the write in C64 clocks.

        • 8-bit unsigned SID register address: 0x00–0xff, with each SID occupying a 0x20-byte range (SID 1: 0x00–0x1f, SID 2: 0x20–0x3f, …​, SID 8: 0xe0–0xff).

        • 8-bit unsigned data value to write.

      • accesses to unconfigured SIDs are ignored, but their delays still apply.

      • returns BUSY if there is already enough data for playback, otherwise OK.

    • TRY_READ (6): reads SID chip register for up to 8 SID chips.

      • data packet must be a 4N+3 bytes long, where N >= 0. The protocol used for the first N packets is the same as the TRY_WRITE protocol, returning potentially BUSY if the delay implied by the READ, or the WRITEs can not yet be buffered.

      • Read packet structure trails the write packet structure:

        • 16-bit unsigned value interpreted as delay before the read in C64 clocks.

        • 8-bit unsigned SID register address: 0x00–0xff, with each SID occupying a 0x20-byte range (SID 1: 0x00–0x1f, SID 2: 0x20–0x3f, …​, SID 8: 0xe0–0xff).

      • accesses to unconfigured SIDs are ignored, but their delays still apply.

      • an ignored read returns READ followed by 0x00.

      • returns BUSY if there is already enough data for playback, otherwise READ and a data byte, which is the read value from SID.

    • GET_VERSION (7): returns the version of the SID Network protocol.

      • sid number is ignored.

      • data packet must be 0 length.

      • returns VERSION (4), followed by:

        • Version: 8-bit unsigned protocol version number.

    • TRY_SET_SAMPLING (8): set the resampling method for all SID devices.

      • sid number is ignored.

      • the data packet is one byte long and contains:

        • Zero for pure decimator (low quality).

        • One for low-pass filtered decimator (high-quality).

      • returns BUSY until audio quiescent, otherwise OK.

    • SET_CLOCKING (9): set the clock source speed for all SID devices.

      • sid number is ignored.

      • the data packet is one byte long and contains:

        • Zero for PAL.

        • One for NTSC.

      • returns BUSY until audio quiescent, otherwise OK.

    • GET_CONFIG_COUNT (10): Query number of SID configurations supported by server.

      • sid number is ignored.

      • data packet is ignored and should be zero length.

      • returns COUNT (5), followed by:

        • Count: 8-bit unsigned number of SID configurations.

    • GET_CONFIG_INFO (11): query the name and model of the SID configuration.

      • sid number specifies the SID configuration index.

      • data packet is ignored and should be zero length.

      • returns INFO (6), followed by:

        • Model: 8-bit unsigned value, 0 = 6581, 1 = 8580.

        • Model name: null-terminated ISO-8859-1 encoded string of up to 255 bytes, excluding the terminator.

    • SET_SID_POSITION (12): set sid position on the audio mix

      • the data packet is one byte long and contains:

        • -100 to zero: audio is panned to left

        • 0 to 100: audio is panned to right

      • it always returns OK.

    • SET_SID_LEVEL (13): set SID level adjustment in dB

      • the data packet is one byte long and contains:

        • 8-bit signed level adjustment in steps of 0.2 dB, 0 means no adjustment.

      • it always returns OK.

    • SET_SID_MODEL (14):

      • the data packet is one byte long and contains:

        • 8-bit unsigned value between 0 <= value <= max_config-1

      • it always returns OK.

    • SET_DELAY (15): set SID output delay in ms

      • the data packet is one byte long and contains:

        • 8-bit unsigned ms delay, 0 means no delay

      • it always returns OK.

    • SET_FADE_IN (16): set fade-in time in ms.

      • sid number is ignored.

      • the data packet is four bytes long and contains:

        • 32-bit unsigned fade-in time in milliseconds.

        • Note: Since only the client knows the song length, you must send this command when the fade-in time is reached (at the start of the tune).

      • returns BUSY until audio quiescent, otherwise OK.

    • SET_FADE_OUT (17): set fade-out time in ms.

      • sid number is ignored.

      • the data packet is four bytes long and contains:

        • 32-bit unsigned fade-out time in milliseconds.

        • Note: Since only the client knows the song length, you must send this command when the fade-out time is reached (near the end of the tune).

      • returns BUSY until audio quiescent, otherwise OK.

    • SET_SID_HEADER (18): set SID header bytes

      • The data packet is at least 124 bytes long and depends on the size of the SID header. It contains:

        • SID header bytes. This optional command can be used to show information of what is currently being played.

      • it always returns OK.

    • TRY_WRITE_EX (19): extended version of TRY_WRITE. Tries to queue a number of write events for up to 16 SID chips and FM OPL devices.

      • data packet must be 5*N bytes long, repeating this structure:

        • 16-bit unsigned value interpreted as delay before the write in C64 clocks.

        • 16-bit unsigned register address:

          • 0x0000–0x01ff: SID register address, with each SID occupying a 0x20-byte range (SID 1: 0x0000–0x001f, SID 2: 0x0020–0x003f, …, SID 16: 0x01e0–0x01ff).

          • 0xdf00–0xdfff: FM OPL register address corresponding to C64 I/O address $DF00–$DFFF.

        • 8-bit unsigned data value to write

      • accesses to disabled FM OPL or unconfigured SIDs are ignored, but their delays still apply.

      • returns BUSY if there is already enough data for playback, otherwise OK.

    • TRY_READ_EX (20): extended version of TRY_READ. Reads a register from up to 16 SID chips or FM OPL devices.

      • data packet must be a 5N+4 bytes long, where N >= 0. The protocol used for the first N packets is the same as the TRY_WRITE_EX protocol, returning potentially BUSY if the delay implied by the READ, or the WRITEs can not yet be buffered.

      • Read packet structure trails the write packet structure:

        • 16-bit unsigned value interpreted as delay before the read in C64 clocks.

        • 16-bit unsigned register address: 0x0000–0x01ff: SID register address, with each SID occupying a 0x20-byte range (SID 1: 0x0000–0x001f, SID 2: 0x0020–0x003f, …, SID 16: 0x01e0–0x01ff).

      • accesses to unconfigured SIDs are ignored, but their delays still apply.

      • an ignored read returns READ followed by 0x00.

      • returns BUSY if there is already enough data for playback, otherwise READ and a data byte, which is the read value from the addressed device.

    • TRY_SET_FM_OPL (21): enable or disable FM OPL for the current connection.

      • sid number is ignored.

      • the data packet is one byte long and contains:

        • Zero or one to disable/enable FM OPL

      • FM OPL is disabled by default on a new connection. Clients should explicitly enable or disable it before playback of each tune.

      • enabling a disabled device resets it and starts processing and audio output. Disabling it stops both.

      • enabling an already enabled device or disabling an already disabled device returns OK without resetting it or interrupting playback. Disabling FM OPL on an unsupported device also returns OK.

      • returns ERROR when enabling FM OPL on a device that does not support it.

      • returns BUSY until audio quiescent, otherwise OK.

Developer notes for JSIDPlay2 and JSIDDevice

These notes explain implementation behavior and the remaining ambiguities in the shared description above. Command numbers and wire layouts follow that description. Java enum names TRY_SET_CLOCKING and TRY_SET_SID_MODEL denote upstream commands SET_CLOCKING (9) and SET_SID_MODEL (14); the names do not change their wire codes.

Framing, errors and timing
  • TCP is a byte stream: a request or response can span multiple reads, and a read can contain parts of multiple requests. Consume the complete declared payload before processing it, and the complete response before sending the next request. The payload length excludes the four-byte header; the maximum payload is 65535 bytes.

  • The optional ERROR text in the shared description has no specified length or terminator. JSIDDevice sends only the ERROR byte (02). JSIDPlay2 reports the error and closes its connection, so an unframed diagnostic string cannot corrupt the next response. Do not wait for optional error text on a persistent connection.

  • JSIDDevice consumes and validates the entire request before applying any part of it. Invalid commands, lengths, addresses and values return one ERROR byte with no partial writes. The server keeps the connection usable after a rejected request. GET_CONFIG_COUNT and GET_CONFIG_INFO ignore their payloads as specified.

  • BUSY accepts no part of the request. Retry the identical request after a short wait, including during initial configuration. In JSIDDevice, SET_SID_MODEL can also return BUSY until audio is quiescent, despite the shared text’s "always OK". Clients should handle BUSY for that command. Quiescence requires both an empty queue and an idle consumer: a short packet can be queued before the sleeping audio thread wakes up, and must drain before replacing chip models or SID arrays.

  • Every timed event advances one global C64 timeline, including all read-side SIDs. Its delay comes before the register access. Ignored writes and reads retain their elapsed time; an ignored read returns zero. An address selects the chip in both read formats; the header SID byte does not override the packed read address.

  • Zero-cycle writes and reads are valid. Standalone TRY_DELAY must advance at least one cycle. Split delays greater than 65535 cycles into multiple requests, using a wide integer for scheduler timestamps before applying fast-forward scaling.

  • Keep batches short to limit jitter, as explained in the shared specification. JSIDPlay2 bounds batches by encoded byte size and elapsed cycles, and sends periodic delays during otherwise silent intervals. A run of zero-cycle events still needs a byte-size limit. FLUSH discards queued events; TRY_RESET resets chip registers.

SID count and runtime configuration
  • GET_CONFIG_COUNT reports available model/filter configurations, not SID-slot capacity. Its count and the INFO model byte are unsigned. INFO names contain up to 255 ISO-8859-1 bytes followed by a mandatory NUL, including at maximum length.

  • The legacy address format supports eight SID slots; the extended format supports sixteen. Servers may support fewer slots. There is no maximum-slot-count query. JSIDPlay2 also respects its local MAX_SIDS limit (15 by default) and allocates only through the highest used SID index in the current mono, stereo, fake-stereo or multi-SID setup.

  • Changing SID count may recreate every chip. JSIDDevice initializes every slot with configuration 0 and resets clock/sampling to PAL/DECIMATE. It resets levels and delays to zero, centers mono and spreads multiple chips evenly left to right. Older releases left slots uninitialized until SET_SID_MODEL; clients should assign a model to each requested slot before timed accesses for compatibility.

  • JSIDPlay2 reconfigures chips in ascending SID order. It resets the whole device once, completes all model/mute configuration, then restores each physical register bank and reapplies mixer controls. Completing every model change first also handles devices that recreate all chips when any model changes. Register restoration bypasses fake-stereo read selection and write mirroring. It retains register programming (frequency, waveform, ADSR, filter and volume), but cannot recover oscillator phase or a running envelope’s state.

  • Local SID-list positions are physical protocol indices. An interior unused slot stays empty and silent; only unused trailing slots may be removed. The allocated remote count covers the highest occupied index, while mono centering uses the number of active chips. A standalone unlock silences an interior slot or reduces the remote count and restores every survivor’s configuration and registers. Releasing the final chip leaves one silent remote chip, because the protocol cannot allocate zero. Retired physical slots send no further accesses; a retired fake-stereo wrapper can still forward to live members of its original address group until the C64 bank is remapped. Holes must never cause mirroring into an unrelated address group.

  • SET_SID_MODEL replaces the selected audio and read-side emulators and resets their state. JSIDDevice applies the current clock to both. Reapply mute settings and restore registers after changing a model. Sampling/clock changes alone retain the SID instances.

  • Protocol version 1 uses header bits: bit 0 selects 6581/8580, bit 1 PAL/NTSC, bit 2 RESAMPLE/DECIMATE. JSIDPlay2 uses one SID in this compatibility mode and does not send version-2 configuration queries or controls. These sampling bits differ from the TRY_SET_SAMPLING payload codes (0 = DECIMATE, 1 = RESAMPLE).

Filter bypass, mute, panning, levels and fades
  • The shared protocol has no filter-enable command. JSIDPlay2 bypasses filtering like its hardware backends: it clears the low four voice/external-input routing bits of SID register $17 on network writes. The resonance bits and mode/volume register $18 are preserved. This bypasses routing; it does not remotely disable the server’s analogue filter model.

  • Each physical chip caches the tune’s original $17 value, including writes made while bypassed. Changing Filter enable immediately replays that chip’s own cached value with the current routing mask and flushes pending writes. Fake-stereo read selection and write mirroring do not redirect this control. Re-enabling therefore restores the latest original routing independently for every physical SID.

  • A changed enable setting adds one ordinary $17 write using TRY_WRITE (5) or TRY_WRITE_EX (19). Reapplying the same setting adds no write. A newly created disabled chip receives this bypass before its cached registers are restored; restoration also applies the mask. No command IDs, count/model/reset commands, or wire layouts are added for a filter toggle. A null or empty filter-preset choice still selects an available configuration for the requested chip model.

  • Network filter presets and the desktop Filter enable checkbox are independent: selecting or refreshing a calibration does not enable a bypassed filter. Stereo and fake-stereo curve redraws retain the flags and selected calibration names.

  • In MUTE, the flag is 0 = unmute, 1 = mute. The upstream phrase "Zero or one to disable/enable voice" is ambiguous; use these flag meanings. Voice indices 0..2 refer to the three SID voices; index 3 is digi muting, introduced in version 3.

  • SET_SID_POSITION is signed two’s complement: negative is left, positive is right. For SID index 0, fully left (-100) is 0c 00 00 01 9c; fully right (+100) is 0c 00 00 01 64. Endianness cannot reverse a one-byte value. JSIDDevice uses full gain on the nearer channel and reduces the other linearly: for p ⇐ 0, left = 1 and right = (100+p)/100; for p >= 0, left = (100-p)/100 and right = 1. One configured SID reaches both channels at full gain. JSIDPlay2 uses embedded panning from v4E/v5 headers, including RSID BASIC tunes; older header versions use the user’s balance settings.

  • SET_SID_LEVEL uses 0.2 dB steps, not centibels. Its signed range -128..127 is -25.6..+25.4 dB. For example, +6 dB is +30 (1e), and -6 dB is -30 (e2). JSIDDevice’s amplitude multiplier is 10^(value/100).

  • SET_DELAY is unsigned, 0..255 milliseconds. Fades use unsigned 32-bit integer milliseconds, 0..4294967295, in big-endian order; no IEEE-754 float is transmitted. For example, 1.25 seconds is 00 00 04 e2. JSIDPlay2 rounds fractional milliseconds to the nearest millisecond and rejects negative, non-finite or overflowing values.

  • As the shared fade comments explain, only the client knows the song length. Send fade-in when it should begin at the start, and fade-out when it should begin near the end. A fade command does not schedule its own start from a song duration.

Metadata and FM OPL
  • SET_SID_HEADER is optional display metadata, without C64 program data. Preserve the original tune’s header when preparing network metadata. Header integers are big-endian, including the unsigned data offset at bytes 6..7.

  • The common specification requires at least 124 payload bytes. JSIDPlay2 pads PSID v1 metadata from 118 to 124 bytes and rewrites the transmitted data offset to 124 for compatibility. It pads larger retained offsets while preserving extension bytes. This does not modify the original tune file.

  • As an input extension, JSIDDevice also accepts raw 118-byte PSID v1 metadata and padded v1 headers retaining offset 118. PSID v2..v5 and v4E (version 0x004e) require at least 124 bytes. RSID v1 is invalid. The data offset must be at least the version’s minimum header size and must fit within the payload; v4E extension bytes must be complete and occupy an even number of bytes after byte 124. Malformed metadata returns ERROR.

  • Extended write addresses 0xdf00..0xdfff include both endpoints. The trailing read address in TRY_READ_EX is a SID address, 0x0000..0x01ff. Although the shared command title mentions FM reads, its read-tail layout defines no FM read address; JSIDDevice rejects FM read tails. Preceding extended writes may include FM. JSIDPlay2 returns FM status reads locally as 0xff.

  • FM is disabled on a new connection. Set its state explicitly for each tune. Ignored FM writes still consume time. An unchanged enable state returns OK without resetting or waiting for quiescence; a changed state may return BUSY. Resetting SIDs also resets enabled FM, retaining its enable state. FLUSH retains enable state too.

Parallel synthesis in JSIDDevice
  • A SID becomes active at the start of the interval preceding its first register write and remains active until reset or replacement. Reserved, unwritten slots are not clocked. JSIDDevice starts synthesis on its audio thread and measures render time over roughly 100 ms of emulated audio. If synthesis takes more than half of that audio time, JSIDDevice adds workers to leave time for mixing and PCM delivery. It reduces the worker count when there is enough headroom. The number of participants is bounded by the available processors and one participant per pair of active chips, rounded up. Mono and stereo stay serial.

  • Each batch contains at most 10000 C64 cycles or 4096 events, whichever comes first. Only already queued events are collected; filling a batch adds no wait. Each chip retains all global intervals and its own register-write order, including zero-cycle fake-stereo writes. An interval crossing a batch boundary applies its write only after the final fragment.

  • Workers generate private sample buffers. The audio thread joins them before applying per-chip delays, fades, levels and panning in stable SID order, followed by stereo resampling and PCM output. FM intervals and writes remain in their original order on that same global timeline. Read-side shadow chips still run on the network thread; this optimization concerns audio synthesis.

  • An empty command queue alone does not mean that reconfiguration is safe: workers can still own the events collected into the current batch. Count, model, clock and sampling changes must wait for the audio consumer to become idle too. Rendering workers are joined when the audio thread ends or is interrupted.

UDP device discovery

This discovery exchange is separate from the TCP command stream and compatible with Wilfred Bos’s SID Device (responder source). It does not add or renumber any TCP commands.

  • Send the nine US-ASCII bytes SidDevice, without a terminator, to the device’s UDP port. This is the same numeric port as its TCP service (6581 by default). JSIDPlay2 searches IPv4 broadcasts on active local interfaces and also probes local addresses, including loopback, to find locally restricted devices.

  • The device replies to the query’s source address and ephemeral UDP source port. The reply is UTF-8 SidDevice,<hostname>,<platform>, without a terminator; for example, SidDevice,studio,Linux 64-bit. JSIDPlay2 accepts replies of at most 512 bytes. JSIDDevice also accepts query suffix/padding bytes for existing clients. There are no binary integers in this exchange, so byte order does not apply.

  • Use the reply’s source IP address and UDP source port as the connection endpoint. The advertised hostname and platform are display text. Do not resolve that hostname to choose a different endpoint. Duplicate replies from the same endpoint are combined; a device reachable at several addresses can appear once per address.

  • JSIDPlay2 waits up to 1.5 seconds, ignores malformed responses and cancels a search when its controls close or the engine changes. Discovery results do not replace the saved hostname until the user selects one. JSIDDevice binds UDP to the TCP listener’s actual address and port and replaces both listeners when connection settings change. With external connections disabled, the configured hostname is used (normally 127.0.0.1), so a loopback-only service is not advertised at the machine’s LAN address. Enabling Allow external connections binds both services to all IPv4 interfaces. Callers from other machines receive discovery replies only when that option is enabled.

Make use of devices implementing the network SID device protocol (JSIDPlay2 as a Client)

To use these SID implementations as a client for playback, you must choose NetSID as the emulation type in the user interface and provide a hostname and port for that. The default is to connect to 127.0.0.1:6581.

In the desktop user interface, expand Network SID and choose Find devices. The search uses the port shown above the button. Select a responding device to save its address and port and reconnect playback. You can also enter the hostname and port manually, including when the device is outside the local broadcast network.

E.g., you can use ConsolePlayer to use these SID implementations for playback.

jsidplay2-console.sh \
	--engine NETSID \
	--NetSIDDevHost 127.0.0.1 \
	--NetSIDDevPort 6581 # (1)
  1. Start ConsolePlayer and use Network SID Device for sound output

Launch Network SID Device (JSIDPlay2 as a Server)

It is possible to have JSIDPlay2 take over the duty of the SID playback for a C64 emulator/player. The Network SID Device tries to open port 6581 where it will listen to connections that describe SID activity.

On Windows, run the packaged executable.

jsiddevice-4.14.exe # (1)
  1. Launch User interface version (console version is not available as an executable, see below)

On Linux and macOS, run these scripts by their paths in the extracted directory.

"/path/to/jsiddevice-4.14/jsiddevice.sh" # (1)
"/path/to/jsiddevice-4.14/jsiddevice-console.sh" # (2)
  1. Launch User interface version

  2. Launch Console version

On macOS, jsiddevice.command and jsiddevice-console.command start the corresponding launchers from Finder. JSIDDevice keeps jsiddevice.properties in the extracted directory. The graphical launcher puts JSIDDevice in the system tray. See Desktop shortcuts for Linux, macOS, and Windows.