This specification describes the standard device interfaces for the Bedrock computer system.

The read column in each device port table indicates if a port can be read from. If a port cannot be read from, a read request to that port will return immediately with a value of zero.

The write column in each device port table indicates if a port can be written to. If a port cannot be written to, a write request to that port will return immediately.

Terminology

Aliased port

An aliased port is a port which is followed by a duplicate of itself. Reads and writes between the two ports are completely interchangeable. This arrangement is used for ports which receive or return long sequences of bytes, and allows two bytes to be read from or written to the port at a time by reading or writing a double to the lower port.

Aliased ports are represented in each device port table as a regular port followed by a port labeled “aliased”.

Port group

A port group is a set of two or more contiguous ports that exposes a value larger than a byte. The port with the lowest address in a group will affect the highest-order eight bits of the value, and the port with the highest address will affect the lowest-order eight bits of the value.

Port groups are represented in each device port table as a regular port followed by one or more ports labeled “continued”.

Cached read

A cached read of a port group will cache the full value exposed by that port group every time that the port with the lowest address in the group is read from. Reading from any port of the group will return the corresponding byte of the cached value, instead of the live value. This is used for port groups that expose fast-changing values, to prevent a value from changing mid-read. The initial cached read value of a port group is zero.

Cached write

A cached write of a port group will write to an intermediary cached value, with the value being acted on by the device only after the port with the highest address in the group is written to. Writing to any port of the group will set the corresponding byte of the cached value, instead of the live value. This is used for port groups that perform dangerous or expensive actions on write, to prevent partial values from being acted upon. The initial cached write value of a port group is zero.

Signed value

Signed values are encoded using two’s compliment. If the highest bit of a signed value is set, the value is negative. Values can be converted between their positive and negative forms by inverting all bits and then incrementing by 1.

Implementation defined

TODO (consistent, defined, documented, unsurprising)

System device

The system device provides information about the configuration of the Bedrock system, and allows the system to enter sleep mode or fork new instances.

Sleep

Writing to the sleep port group will perform a cached write, putting the system to sleep until a wake request is received from an eligible device.

The write operation will not return until the system wakes from sleep. Each bit of the value written represents a slot on the device bus, with a being set only if that device is allowed to wake the system from sleep. The highest-order bit represents slot 0, and the lowest-order bit represents slot 15.

Any device can send a wake request to the system device. When the system device receives a wake request from a device, that device is flagged. When the system enters sleep mode, if a device is flagged and has been allowed to wake the system from sleep, the flag for that device is cleared, the value of the wake port becomes the slot number of that device, and the system will wake. If there are multiple eligible devices, the device that least recently woke the system will be chosen.

Wake

Reading from the wake port will return the slot number of the device that most recently woke the system from sleep. The initial value of this port is zero.

Fork

Writing to the fork port will start a new Bedrock instance, if supported by this system. The program memory of this instance will be copied into the program memory of the new instance, and the new instance will become active.

If a new instance could not be started, the program counter and stack pointers of this instance are set to zero.

Device name

Each device name port is associated with a text buffer containing the name of a custom device as a null-terminated UTF-8 string, or a blank string if no such device exists.

Reading from a port will return the next byte of the associated text buffer, or a zero byte if all bytes have been returned.

Writing to a port will restart the associated text buffer.

Name

The name port is associated with a text buffer containing the name and version of this Bedrock system as a null-terminated UTF-8 string.

The format of the string is the program name, followed by the slash character 0x2F, followed by the program version. The program version is not required to fit any particular format, but it is recommended that it is not prefixed with v or version.

Reading from the name port will return the next byte of the associated text buffer, or a zero byte if all bytes have been returned.

Writing to the name port will restart the associated text buffer.

Authors

The authors port is associated with a text buffer containing a list of authors of this Bedrock system as a null-terminated UTF-8 string.

The format of the string is a list of author names, with each name separated from the next by the newline character ‘0A’. A newline character following the final name is optional.

Reading from the author port will return the next byte of the associated text buffer, or a zero byte if all bytes have been returned.

Writing to the author port will restart the associated text buffer.

Program memory

Reading from the program memory port group will return the size of the program memory on this system. A value of zero represents 65536 bytes.

Working stack

Reading from the working stack port will return the size of the working stack on this system. A value of zero represents 256 bytes.

Return stack

Reading from the return stack port will return the size of the return stack on this system. A value of zero represents 256 bytes.

Connected devices

Reading from the available devices port group will return a double representing the set of devices connected to this system. Each bit of the value represents a slot on the device bus, with a being set only if a device is connected to that slot. The highest-order bit represents slot 0, and the lowest-order bit represents slot 15.

Memory device

The memory device provides access to up to 16 megabytes of expansion memory.

This device will never send a wake request to the system device.

Expansion memory is provisioned in 256-byte units called pages, up to a maximum of 65,535 pages (16,776,960 bytes).

The initial value of each byte on a page is zero. The initial number of pages provisioned is implementation defined.

Head

Expansion memory is accessed via two read-write heads. Each head is associated with a page port and an address port. The memory address referenced by a head is equal to the base page offset of that head (determined by the associated page port), multiplied by 256, and then added to the address offset (determined by the associated address port).

Reading from a head port will return the byte at the memory address referenced by that head, and then the associated address port will be incremented by 1, wrapping to zero on overflow. The behaviour when an unprovisioned memory address is read from is implementation defined.

Writing to a head port will write the byte to the memory address referenced by that head, and then the associated address port will be incremented by 1, wrapping to zero on overflow. The behaviour when an unprovisioned memory address is written to is implementation defined.

Page

Reading from this port group will return the base page offset of the associated head. The initial base page offset for each head is zero.

Writing to this port group will perform a cached write, setting the base page offset of the associated head on commit.

Address

Reading from this port group will return the address offset of the associated head. The initial address offset for each head is zero.

Writing to this port group will perform a cached write, setting the address offset of the associated head on commit.

Page count

Reading from this port group will return the number of pages of expansion memory provisioned for use. The number of pages of expansion memory initially provisioned for use is implementation defined.

Writing to this port group will perform a cached write, requesting that a number of pages be provisioned for use equal to the value written on commit.

If the number of pages to be provisioned is greater than the number currently provisioned, pages will be provisioned in ascending order until the target number is reached or the available memory is exhausted. The initial value of each byte on a newly-provisioned page is zero.

If the number of pages to be provisioned is less than the number currently provisioned, pages will be deprovisioned in descending order until either the target number or an implementation defined minimum is reached.

Page copy

Writing to this port group will perform a cached write, copying a number of pages equal to the value written on commit.

The initial source page will be the page addressed by the base page offset of the second head, and the initial destination page will be the page addressed by the base page offset of the first head. The contents of the source page will be copied to the destination page, and then the source page and destination page will increment by 1, repeating until either the target number of pages has been copied or an unprovisioned page is reached.

Math device

The math device provides access to efficient implementations of common math operations.

This device will never send a wake request to the system device.

The math device performs coordinate-space conversions between two 2-dimensional points, called the cartesian point and the polar point.

The horizontal and vertical cartesian components of a point are represented by signed 16-bit integers. The polar radius component of a point is represented by an unsigned 16-bit integer. The polar angle component of a point is represented by an unsigned 16-bit integer, the angle unit being \frac{1}{65536} of a full turn anticlockwise from the positive horizontal direction.

If the value of a component would fall outside the specified range after conversion from the other coordinate space, the value returned for that component is implementation defined.

Reading from the x component and y component port groups will return the cartesian components of the polar point, and reading from the r component and θ component port groups will return the polar components of the cartesian point.

Writing to the x component and y component port groups will set the position of the cartesian point, and writing to the r component and θ component port groups will set the position of the polar point.

x component

Reading from the x component port group will return the horizontal cartesian component of the polar point. The initial value is zero.

Writing to the x component port group will set the horizontal cartesian component of the cartesian point to the value written.

y component

Reading from the y component port group will return the vertical cartesian component of the polar point. The initial value is zero.

Writing to the y component port group will set the vertical cartesian component of the cartesian point to the value written.

r component

Reading from the r component port group will return the polar radius component of the cartesian point. The initial value is zero.

Writing to the r component port group will set the polar radius component of the polar point to the value written.

θ component

Reading from the θ component port group will return the polar angle component of the cartesian point. The initial value is zero.

Writing to the θ component port group will set the polar angle component of the polar point to the value written.

Product

Reading from the product port group will return the product of the multiplication of the horizontal component of the cartesian point by the vertical component. The horizontal and vertical components of the cartesian point are treated as unsigned integers for this operation.

Quotient

Reading from the quotient port group will return the quotient of the division of the horizontal component of the cartesian point by the vertical component. If the vertical component is zero, the value returned will be zero. The horizontal and vertical components are treated as unsigned integers for this operation.

Remainder

Reading from the remainder port group will return the remainder of the division of the horizontal component of the cartesian point by the vertical component. If the vertical component is zero, the value returned will be zero. The horizontal and vertical components are treated as unsigned integers for this operation.

Clock device

The clock device provides access to the time, the date, and four countdown timers.

This device will send a wake request to the system device when a countdown timer expires.

Year

Reading from the year port will return the number of full years elapsed since midnight of January 1st 2000. A value of zero represents the year 2000, and the maximum value 0xFF represents the year 2255. The value returned past the year 2255 is implementation defined.

Writing to the year port will set the year stored in the system clock to the year represented by the value written, if supported by the host system.

Month

Reading from the month port will return the number of full months elapsed since midnight of January 1st. A value of zero represents the month of January, and the maximum value 0x0B represents the month of December.

Writing to the month port will set the month stored in the system clock to the month represented by the value written, if supported by the host system.

Day

Reading from the day port will return the number of full days elapsed since midnight of the first day of the month. A value of zero represents the first day of the month, and the maximum value 0x1E represents the thirty-first day of the month.

Writing to the day port will set the day stored in the system clock to the day represented by the value written, if supported by the host system.

Hour

Reading from the hour port will return the number of full hours elapsed since midnight. A value of zero represents 12 o’clock midnight, and the maximum value 0x17 represents 11 o’clock at night.

Writing to the hour port will set the hour stored in the system clock to the hour represented by the value written, if supported by the host system.

Minute

Reading from the minute port will return the number of full minutes elapsed since the start of the hour. A value of zero represents the zeroth minute, and the maximum value 0x3B represents the fifty-nineth minute.

Writing to the minute port will set the minute stored in the system clock to the minute represented by the value written, if supported by the host system.

Second

Reading from the second port will return the number of full seconds elapsed since the start of the minute. A value of zero represents the zeroth second, and the maximum value 0x3B represents the fifty-nineth second. The behaviour around leap seconds is implementation defined.

Writing to the second port will set the second stored in the system clock to the second represented by the value written, if supported by the host system.

Uptime

Reading from the uptime port group will perform a cached read, returning the number of full 1/256 second durations elapsed since the beginning of program evaluation. The value will wrap to zero on overflow.

Timer

Each timer port group is associated with a countdown timer. The duration remaining before a timer expires is given as a number of full 1/256 second durations, with the maximum value 0xFFFF representing a duration of approximately four minutes and sixteen seconds. Each timer continuously counts down to zero, expiring when the remaining duration transitions from one to zero. The initial value of each timer is zero.

Reading from a timer port group will perform a cached read, returning the duration remaining before the associated timer expires.

Writing to a timer port group will perform a cached write, setting the duration of the associated timer to the value written on commit.

Input device

The input device provides access to a pointer device, a keyboard, and four gamepads.

This device will send a wake request to the system device when the pointer active state or the keyboard active state changes, or when a pointer button or gamepad button or navigation control or modifier key is pressed or released, or when a character is received from the keyboard device, or when the pointer position changes while the pointer device is active, or when the horizontal or vertical scroll distances change.

Pointer position

The pointer position is the position of the screen pixel that was most recently beneath the pointer. This position is given as a pair of horizontal and vertical components, each represented by a signed 16-bit integer. The top-left pixel of the screen is the origin, with the horizontal component increasing rightward and the vertical component increasing downward. The pointer should remain active if it leaves the screen bounds while at least one pointer button is held.

Reading from a pointer position port group will perform a cached read, returning the position of the pointer along the associated axis.

Scroll distance

Scroll distance is stored as the signed cumulative distance scrolled in pixels along each of the horizontal and vertical axis. The initial distance scrolled along each axis is zero.

The horizontal scroll distance increases when scrolling rightward and decreases when scrolling leftward, saturating at bounds. Scrolling rightward is the action that would slide content leftward, revealing content to the right.

The vertical scroll distance increases when scrolling downward and decreases when scrolling upward, saturating at bounds. Scrolling downward is the action that would slide content upward, revealing content below.

Reading from a scroll distance port will return the distance scrolled along the associated axis, and then that distance will be reset to zero.

Pointer buttons

Reading from this port will return a byte representing the held states of up to eight buttons associated with the pointer device, as per the following table. A bit is set only while the corresponding pointer button is held down.

If the pointer device is a right-handed computer mouse, the primary button is the left mouse button, the secondary button is the right mouse button, and the tertiary button is the middle mouse button. For a left-handed computer mouse, the primary and secondary buttons are switched.

If the pointer device is a touchscreen, the primary button is the touchscreen surface.

The auxillary buttons are implementation defined.

Pointer active

A pointer device is active only while coordinates are being received from the pointer device. If the pointer device is a touchscreen, it is only active while touched. If the pointer leaves the screen bounds, the pointer should remain active until all pointer buttons are released. The native system cursor should be hidden while the pointer device is active so that programs can render their own cursor.

Reading from this port will return the value 0xFF if a pointer device is active, otherwise a zero byte will be returned.

Navigation

Reading from this port will return a byte representing the held states of eight generic navigation controls, as per the following table. A bit is set only while the corresponding navigation control is held down.

If a keyboard device is available, the up, down, left, and right arrow keys maps to the corresponding navigation controls, the enter key maps to the confirm navigation control, the escape key maps to the cancel navigation control, the tab key maps to the next navigation control, and the tab key while the shift modifier is held maps to the previous navigation control.

If a gamepad is connected to the first gamepad port, the up, down, left, and right gamepad buttons map to the corresponding navigation controls, the A button maps to the confirm navigation control, the B button maps to the cancel navigation control, the left bumper maps to the previous navigation control, and the right bumper maps to the next navigation control.

Modifiers

Reading from this port will return a byte representing the held states of up to eight keyboard modifier keys, as per the following table. A bit is set only while the corresponding modifier key is held down.

The auxillary modifiers are implementation defined.

Keyboard active

A keyboard device is active only while it is ready to receive input. If the keyboard device is an on-screen keyboard, it will only be active when visible.

Reading from this port will return the value 0xFF if a keyboard device is active, otherwise a zero byte will be returned.

Writing to this port will change the visibility of an existing software keyboard. A non-zero value will request that the software keyboard is made visible, and a zero value will request that the software keyboard is hidden.

Character

This port is associated with a first-in first-out byte queue. When a character is received from a keyboard, the character is pushed to the end of the queue as a UTF-8 encoded byte sequence if there is sufficient capacity. The character value is not modified by the control modifier. The value of the newline character is 0x0A, not 0x0D or 0x0D0A. The length of the queue is implementation defined.

Reading from this port will remove and return the byte at the front of the queue. If the queue is empty, a zero byte will be returned.

Writing to this port will remove all bytes from the queue.

Gamepad

Reading from a gamepad port will return a byte representing the held states of eight buttons on an associated gamepad, as per the following table. A bit is set only while the corresponding gamepad button is held down.

The A button maps to the affirmative gamepad button, the B button maps to the negative gamepad button, the X button maps to the primary action gamepad button, and the Y button maps to the secondary action gamepad button.

In the PlayStation control scheme, the cross button is the affirmative button, the circle button is the negative button, the square button is the primary action button, and the triangle button is the secondary action button.

In the XBox and Nintendo control schemes, the A button is the affirmative button, the B button is the negative button, the X button is the primary action button, and the Y button is the secondary action button.

If a gamepad has an analog stick, the up, down, left, and right directions of the stick will map to the corresponding direction buttons.

Screen device

The screen device provides access to a two-layer raster screen with a configurable 16 colour palette.

This device will send a wake request to the system device when the screen contents have been damaged, due to the screen being resized or overdrawn by an external process.

The screen contains two layers, the foreground layer and the background layer. Each screen pixel is rendered using the foreground colour of the pixel if it isn’t colour zero, and the background colour of the pixel otherwise. The initial foreground and background colour of each pixel is colour zero.

The screen has a configurable palette of 16 colours, labelled zero through fifteen. Colours can be selected from a 12-bit RGB colour space, allowing for 4096 unique colours. The initial value of each colour in the palette is implementation defined.

The screen uses a signed coordinate space ranging from 0x8000 to 0x7FFF.

Implementations of the screen device should use double-buffering to reduce flickering. Buffers should be flipped each time the system enters sleep mode.

Draw cursor

The draw cursor is a pair of pixel coordinates which will be used by the next draw operation, stored as a pair of signed values. The top-left pixel of the screen has coordinates of zero, with the horizontal coordinate increasing rightward and the vertical coordinate increasing downward. The initial cursor coordinates are zero.

Reading from a cursor position port group will return the value of the associated coordinate of the draw cursor.

Writing to a cursor position port group will set the value of the associated coordinate of the draw cursor to the value written.

Dimensions

Reading from a dimensions port group will perform a cached read, returning the length of the associated dimension of the screen in pixels. If no screen is available, the value returned is zero. The initial dimensions of the screen are implementation defined.

Writing to a dimensions port group will perform a cached write, requesting that the length of the associated dimension of the screen be set and locked to the value written on commit.

Palette

Writing to this port group will perform a cached write, writing a colour to the palette on commit. The upper four bits of the value written determine the palette index that will be overwritten by this colour, and the remaining bits represent a 12-bit RGB colour. The upper, middle, and lower four bits of the colour value represent the intensities of the red, green, and blue colour channels.

For systems with a two-colour screen, every second palette index maps to the on colour, and every other index maps to the off colour. For systems with a three-colour screen, every fourth palette index instead maps to the middle colour. For systems with a four-colour screen, the first palette index of every second pair instead maps to the dim middle colour, and the second palette index of every second pair instead maps to the bright middle colour.

Sprite colours

The sprite colours are the set of four palette colours used when drawing a sprite to the screen. They are stored as four 4-bit palette indices packed together as a 16-bit value, starting with the highest four bits being sprite colour 0. The initial value of the 16-bit sprite colour value is zero.

Writing to this port group will set the 16-bit sprite colour value to the value written.

Sprite

A sprite is an eight by eight pixel image. A 1-bit sprite can be drawn with up to two colours, and a 2-bit sprite can be drawn with up to four colours.

The sprite buffer is a 16 byte ring buffer that holds the pixel data used when drawing a sprite to the screen. The buffer pointer is a register that points to the next available byte of buffer memory. The initial value of each byte of the sprite buffer is zero. The initial value of the buffer pointer is implementation defined.

The sprite buffer is divided into two planes by the buffer pointer. The upper plane is the eight bytes of sprite memory which include and logically follow the byte referenced by the buffer pointer. The lower plane is the eight bytes of sprite memory which logically precede the byte referenced by the buffer pointer.

A 1-bit sprite is defined by the lower plane of the sprite buffer. Each byte of the lower plane defines a row, ordered from top to bottom. Each bit of each byte defines a pixel, ordered from left to right, with the highest bit representing the left-most pixel of the row. If the bit is set then the pixel will be drawn as sprite colour 1, otherwise it will be drawn as sprite colour 0.

A 2-bit sprite is defined by both planes of the sprite buffer. Each bit of each plane maps to a sprite pixel in the same manner as with a 1-bit sprite, with the upper plane defining the upper bit of each pixel and the lower plane defining the lower bit of each pixel. A pixel will be drawn as sprite colour 3 if both the upper and lower bits of the pixel are set, or sprite colour 2 if only the upper bit is set, or sprite colour 1 if only the lower bit is set, or sprite colour 0 otherwise.

Writing to a sprite port will set the byte referenced by the buffer pointer to the byte written, and then will increment the buffer pointer by 1, wrapping around to zero on overflow.

Draw

Writing to this port will perform a draw operation according to the value written. The byte written is called the draw byte, with the upper four bits determining the operation to be performed as per the following table, and the lower four bits representing either a colour or a sprite transformation.

If bit 0x10 of the draw byte is set then the lower four bits of the draw byte represent the active transformation, otherwise they represent the active colour.

The current cursor position is the current position of the draw cursor. The previous cursor position is the position of the draw cursor during the previous draw operation, or zero if no draw operation has been performed.

When drawing a pixel to a layer, the pixel on that layer at the current cursor position will be set to the active colour.

When filling a layer with a solid colour, each pixel on that layer will be set to the active colour.

When drawing a 1-bit or 2-bit sprite to a layer, the sprite is read from the sprite buffer, then the active transformation is applied to the sprite, and then the sprite is drawn to the layer with the top-left corner of the sprite at the current cursor position.

When drawing a solid line to a layer, each pixel on that layer which belongs to the shortest line of pixels connected orthogonally or diagonally from the previous cursor position to the current cursor position will be set to the active colour.

When drawing a solid rectangle to a layer, each pixel on that layer which belongs to the smallest axis-aligned rectangle containing both the previous cursor position and the current cursor position will be set to the active colour.

When drawing a 1-bit textured line to a layer, a 1-bit sprite is read from the sprite buffer, then the active transformation is applied to the sprite, and then each pixel on that layer which belongs to the shortest line of pixels connected orthogonally or diagonally from the previous cursor position to the current cursor position will be drawn as the corresponding sprite pixel.

When drawing a 1-bit textured rectangle to a layer, a 1-bit sprite is read from the sprite buffer, then the active transformation is applied to the sprite, and then each pixel on that layer which belongs to the smallest axis-aligned rectangle containing both the previous cursor position and the current cursor position will be drawn as the corresponding sprite pixel.

The sprite pixel which corresponds with a given screen pixel is the sprite pixel that, were the sprite to be drawn to the top-left pixel of the screen and then tiled seamlessly rightwards and downwards, would be drawn to the given screen pixel.

If bit 0x1 of the active transformation is set, the order of the columns of the sprite will be reversed.

If bit 0x2 of the active transformation is set, the order of the rows of the sprite will be reversed.

If bit 0x4 of the active transformation is set, the sprite will be transposed such that each row of the sprite from top to bottom becomes a column from left to right, with the pixels in each row from left to right becoming the pixels of a column from top to bottom. This transformation is applied after the row and column reversal transformations.

If bit 0x8 of the active transformation is set, each pixel of the sprite which would be drawn as sprite colour 0 is instead not drawn.

Move

Writing to this port will move the cursor to a new position relative to the current position. The upper two bits of the byte written determine the direction to move, and the lower six bits determine the distance in pixels to move. The maximum distance to move is 63 pixels.

If bit 0x80 is unset, the distance will be added to the axis value, else the distance will be subtracted from the axis value. If bit 0x40 is unset, the value of the horizontal axis will be changed, else the value of the vertical axis will be changed.

Tone device

The tone device is intended to provide access to rudimentary tone generation capabilities, similar to the sound capabilities of the MOS 6581 or the Nintendo Gameboy. Desired applications range from simple beeps and boops to gritty and complex chiptune music. In particular, I’m interested in designing around four voices, with the ability to configure volume, pitch, and envelope per channel. The minimum viable speaker would be a piezoelectric speaker.

The MOS 6581 has three voices, with four waveforms selectable per voice: a variable-pulse-width square wave, a triangle wave, a saw wave, and pseudorandom noise. A low pass and high pass filter can be applied to the output.

The Nintendo Gameboy has a more constrained sound system. Detailed documentation can be found at gbdev.io/pandocs/Audio.html.

The biggest challenge is going to be dealing with latency in sending data to the device, the design of Bedrock is not nearly real-time enough for real-time audio. The likely solution to this will be to allow offloading a whole sequence of note data into the tone device up front and letting the device handle playback. This will allow slower systems to play music smoothly, while still allowing faster systems to trigger notes real-time.

The wake functionality can be used to wake the system when the note sequence finishes or is about to finish. A double-buffer system would be useful, where note data can be written to the back buffer while the front buffer plays, and the system can wake when the buffers flip.

Sampler device

The sampler device is intended to provide access to complex sound playback capabilities via pre-recorded PCM samples. This is intended to be used for music making and game sound effects. The sampler device can be used simultaneously with the tone device.

One possible direction to take with the design of this device would be to allow a bank of sounds to be pushed to the device and then triggered individually with volume control. Consider a ring buffer for input, with the ability to save the current buffer contents as one sound in a bank.

A second approach would be to use an addressable buffer for input, and to have multiple independent playheads reading and playing out configurable portions of the buffer at various speeds. This would allow for more advanced techniques where the buffer can be modified live while sounds are playing and data can be shared between samples, but it might be impractical to implement.

Stream device

The stream device provides access to two bi-directional data streams, a local stream and a remote stream. The local stream is used for inter-process communication and the remote stream is used for network access.

The local bytestream is used to exchange data with a local process. This can be used to interface with the standard input and output streams provided by many operating systems (commonly abbreviated as stdin and stdout).

The remote bytestream is used to exchange data with a remote machine on a network. This can be used to exchange data with a machine on a local network or over the internet, using any convenient protocol.

Connection state

Reading from a connection state port will return the value 0xFF if the associated channel is connected to another system, otherwise a zero byte will be returned.

Remote bytestream

The remote bytestream... text buffer stuff

Writing to a connection state port associated with the remote bytestream will

Transmission state

Reading from a transmission state port will return the value 0xFF if the associated channel is

Input queue

Output queue

Bytestream

Clipboard device

File device

Environment device