The arc instruction adds the specified arc subpath to the existing path, creating a new path if no path exists. The path created can be modified further by other path-type instructions, and finally stroked, filled, and/or closed.

Fills the current path with the specified color. This instruction completes the current path. Future path instructions will begin a new path.

Applies the current path as the clipping path. Future operations will only draw within the current path. Note that future clip instructions will also be limited by this path. To set a completely new clipping path, you must first reset the layer with a reset instruction. If you wish to only reset the clipping path, but preserve the current transform matrix, push the layer state before setting the clipping path, and pop the layer state to reset.

Closes the current path by connecting the start and end points with a straight line.

Copies image data from the specified rectangle of the specified layer or buffer to a different location of another specified layer or buffer.

Strokes the current path with the specified color. This instruction completes the current path. Future path instructions will begin a new path.

Sets the client's cursor to the image data from the specified rectangle of a layer, with the specified hotspot.

Adds the specified cubic bezier curve subpath.

Removes the specified layer. The specified layer will be recreated as a new layer if it is referenced again.

Sets the given affine transformation matrix to the layer. Unlike transform, this operation is independent of any previously sent transformation matrix. This operation can be undone by setting the layer's transformation matrix to the identity matrix using distort

Resets the transform matrix of the specified layer to the identity matrix.

Fills the current path with a tiled pattern of the image data from the specified layer. This instruction completes the current path. Future path instructions will begin a new path.

Adds the specified line subpath.

Strokes the current path with a tiled pattern of the image data from the specified layer. This instruction completes the current path. Future path instructions will begin a new path.

Moves the given layer to the given location within the specified parent layer. This operation is applicable only to layers, and cannot be applied to buffers (layers with negative indices). Applying this operation to the default layer (layer 0) also has no effect.

Restores the previous state of the specified layer from the stack. The state restored includes the transformation matrix and clipping path.

Saves the current state of the specified layer to the stack. The state saved includes the current transformation matrix and clipping path.

Adds a rectangular path to the specified layer.

Resets the transformation and clip state of the layer.

Sets the given client-side property to the specified value. Currently there is only one property: miter-limit, the maximum distance between the inner and outer points of a miter joint, proportional to stroke width (if miter-limit is set to 10.0, the default, then the maximum distance between the points of the joint is 10 times the stroke width).

Sets the opacity of the given layer.

Sets the size of the specified layer.

Starts a new subpath at the specified point.

Transfers image data from the specified rectangle of the specified layer or buffer to a different location of another specified layer or buffer, using the specified transfer function.

For a list of available functions, see the definition of guac_transfer_function within the guacamole/protocol-types.h header included with libguac.

Applies the specified transformation matrix to future operations. Unlike distort, this operation is dependent on any previously sent transformation matrices, and only affects future operations. This operation can be undone by setting the layer's transformation matrix to the identity matrix using identity, but image data already drawn will not be affected.

The ack instruction acknowledges a received data blob, providing a status code and message indicating whether the operation associated with the blob succeeded or failed. A status code other than SUCCESS implicitly ends the stream.

Allocates a new stream, associating it with the given audio metadata. Audio data will later be sent along the stream with blob instructions. The mimetype given must be a mimetype previously specified by the client during the handshake procedure. Playback will begin immediately and will continue as long as blobs are received along the stream.

Sends a blob of data along the given stream. This blob of data is arbitrary, base64-encoded data, and only has meaning to the Guacamole client or server through the metadata assigned to the stream when the stream was allocated.

Allocates a new stream, associating it with the given clipboard metadata. The clipboard data will later be sent along the stream with blob instructions. If sent by the client, this data will be the contents of the client-side clipboard. If sent by the server, this data will be the contents of the clipboard within the remote desktop.

The end instruction terminates an open stream, freeing any client-side or server-side resources. Data sent to a terminated stream will be ignored. Terminating a stream with the end instruction only denotes the end of the stream and does not imply an error.

Allocates a new stream, associating it with the given arbitrary file metadata. The contents of the file will later be sent along the stream with blob instructions. The full size of the file need not be known ahead of time.

Allocates a new stream, associating it with the metadata of an image update, including the image type, the destination layer, and destination coordinates. The contents of the image will later be sent along the stream with blob instructions. The full size of the image need not be known ahead of time.

Encodes part of one or more instructions within a single instruction, associating that packet of data with a stream index. Future nest instructions with the same stream index will append their data to the same logical stream on the client side. Once nested data is received on the client side, the client immediately executes any completed instructions within the associated stream, in order.

Allocates a new stream, associating it with the given arbitrary named pipe metadata. The contents of the pipe will later be sent along the stream with blob instructions. Pipes in the Guacamole protocol are unidirectional, named pipes, very similar to a UNIX FIFO or pipe. It is up to client-side code to handle pipe data appropriately, likely based upon the name of the pipe, which is arbitrary. Pipes may be opened by either the client or the server.

Allocates a new stream, associating it with the given video metadata. Video data will later be sent along the stream with blob instructions. The mimetype given must be a mimetype previously specified by the client during the handshake procedure. Playback will begin immediately and will continue as long as blobs are received along the stream.

Allocates a new stream, associating it with the name of a stream previously requested by a get instruction. The contents of the stream will be sent later with blob instructions. The full size of the stream need not be known ahead of time.

Allocates a new object, associating it with the given arbitrary filesystem metadata. The contents of files and directories within the filesystem will later be sent along streams requested with get instructions or created with put instructions.

Requests that a new stream be created, providing read access to the object stream having the given name. The requested stream will be created, in response, with a body instruction.

Stream names are arbitrary and dictated by the object from which they are requested, with the exception of the root stream of the object itself, which has the reserved name "/". The root stream of the object has the mimetype "application/vnd.glyptodon.guacamole.stream-index+json", and provides a simple JSON map of available stream names to their corresponding mimetypes. If the object contains a hierarchy of streams, some of these streams may also be "application/vnd.glyptodon.guacamole.stream-index+json".

For example, the ultimate content of the body stream provided in response to a get request for the root stream of an object containing two text streams, "A" and "B", would be the following:

{
    "A" : "text/plain",
    "B" : "text/plain"
}

Allocates a new stream, associating it with the given arbitrary object and stream name. The contents of the stream will later be sent with blob instructions.

Undefines an existing object, allowing its index to be reused by another future object. The resource associated with the original object may or may not continue to exist - it simply no longer has an associated object.

Specifies which audio mimetypes are supported by the client. Each parameter must be a single mimetype, listed in order of client preference, with the optimal mimetype being the first parameter. This is the third instruction sent during the handshake phase.

Begins the connection using the previously specified protocol with the given arguments. This is the last instruction sent during the handshake phase.

The parameters of this instruction correspond exactly to the parameters of the received args instruction. If the received args instruction has, for example, three parameters, the responding connect instruction must also have three parameters.

Specifies which image mimetypes are supported by the client. Each parameter must be a single mimetype, listed in order of client preference, with the optimal mimetype being the first parameter. This is the fifth instruction sent during the handshake phase.

It is expected that the supported mimetypes will include at least "image/png" and "image/jpeg", and the server may safely assume that these mimetypes are supported, even if they are absent from the handshake.

Requests that the connection be made using the specified protocol, or to the specified existing connection. Whether a new connection is established or an existing connection is joined depends on whether the ID of an active connection is provided. The Guacamole protocol dictates that the IDs generated for active connections (provided during the handshake of those connections via the ready instruction) must not collide with any supported protocols.

This is the first instruction sent during the handshake phase.

Specifies the client's optimal screen size and resolution. This is the second instruction sent during the handshake phase.

Specifies which video mimetypes are supported by the client. Each parameter must be a single mimetype, listed in order of client preference, with the optimal mimetype being the first parameter. This is the fourth instruction sent during the handshake phase.

Reports the expected format of the argument list for the protocol requested by the client. This message can be sent by the server during the handshake phase only.

The parameters of the args instruction are the names of all parameters accepted by the server for the protocol in selected by the client, in order. The client's responding connect instruction must the values of each of these parameters in the same order.

Notifies the server that the connection is about to be closed by the client. This message can be sent by the client during any phase, and takes no parameters.

The client "nop" instruction does absolutely nothing, has no parameters, and is universally ignored by the Guacamole server. Its main use is as a keep-alive signal, and may be sent by Guacamole clients when there is no activity to ensure the socket is not closed due to timeout.

Reports that all operations as of the given server-relative timestamp have been completed. If a sync is received from the server, the client must respond with a corresponding sync once all previous operations have been completed, or the server may stop sending updates until the client catches up. For the client, sending a sync with a timestamp newer than any timestamp received from the server is an error.

Both client and server are expected to occasionally send sync to report on current operation execution state.

Notifies the client that the connection is about to be closed by the server. This message can be sent by the server during any phase, and takes no parameters.

Notifies the client that the connection is about to be closed due to the specified error. This message can be sent by the server during any phase.

The log instruction sends an arbitrary string for debugging purposes. This instruction will be ignored by Guacamole clients, but can be seen in protocol dumps if such dumps become necessary. Sending a log instruction can help add context when searching for the cause of a fault in protocol support.

Reports that a user on the current connection has moved the mouse to the given coordinates.

The server "nop" instruction does absolutely nothing, has no parameters, and is universally ignored by Guacamole clients. Its main use is as a keep-alive signal, and may be sent by guacd or client plugins when there is no activity to ensure the socket is not closed due to timeout.

The ready instruction sends the ID of a new connection and marks the beginning of the interactive phase of a new, successful connection. The ID sent is a completely arbitrary string, and has no standard format. It must be unique from all existing and future connections and may not match the name of any installed protocol support.

Indicates that the given timestamp is the current timestamp as of all previous operations. The client must respond to every sync instruction received.

Both client and server are expected to occasionally send sync to report on current operation execution state.

Sends the specified key press or release event.

Sends the specified mouse movement or button press or release event (or combination thereof).

Specifies that the client's optimal screen size has changed from what was specified during the handshake, or from previously-sent "size" instructions.