MIDAS is a client/server application that allows you to deliver the
graphics power of a remote display to your local workstation.

It works by redirecting the OpenGL of an unmodified application to a
different display, then sending the imagery back into the window of the
original application. In this way, the hardware-accelerated OpenGL
features of a graphics card may be used on a completely separate
display. It decouples the OpenGL implementation from the final display.

Concept

In the X Window System, OpenGL is delivered to the end user through the
GLX protocol. This protocol embeds OpenGL commands inside the X11
stream. All OpenGL primitives generated by the application are
delivered over the network to the end user's desktop for rasterization
and display.

While this provides much needed network transparency for remote
applications, it is not very flexible when it comes to the hardware
doing the rasterization. Only the user's desktop machine can be used to
accelerate the display.

MIDAS (Merlot Image Delivery Application Server) augments the services
that X11 and GLX provide by redirecting the GLX commands to a second
"high end" machine. Primitives are rendered there, and imagery is
shipped back to the user's desktop for display. Since the imagery is
blitted back into the original application's window, the user has the
same experience with the application as they are used to.

One major advantage of this is that the second machine can be a much
higher-end machine than is feasible to put on a user's desktop. Plus,
it can be a shared resource. When one user is not using it, others can.
This makes for a very flexible and cost effective remote delivery
solution.

Another advantage is that all rendering is done in "direct" mode. Most
OpenGL applications will see dramatic speedups when rendering is done
on a local GLX/X11 display. Thus, while MIDAS adds additional overhead
due to its processing, this overhead may be more than made up by the
speedups of using direct rendering.

MIDAS may also be used in a second, more advanced
mode, where the application is run on a different machine than the one
doing the rendering or the final display. This method has the advantage
of a complete decoupling of the application, the rendering, and the final
display. However, it removes the advantage of direct rendering.

Notable Technology and Merlot

To insert itself into an unmodified OpenGL application, MIDAS makes
use of the system's runtime loader. The midas_launch script sets up
environment variables that cause the system to load MIDAS's library
before the system's OpenGL library is loaded. MIDAS's library
contains implementations of certain OpenGL functions (glXSwapBuffers,
glXMakeCurrent, etc.) that allow the GLX stream to be redirected.
This is similar to how systems like Chromium work.

MIDAS makes use of compression and temporal coherence to reduce the
payload that is transmitted over the network. For each window, the
frame is compared to the frame immediately preceding it, and a delta
is calculated. Only this delta is considered for transmission.

- =

After a delta is computed, the image is then compressed. MIDAS
currently supports two different forms of compression: RLE
(Run-Length Encoding) and gzip compression. RLE compression (the
default) provides the least compression, but requires the least
computation to encode and decode. Gzip compression at level 6
requires a good amount of computation, and so is most appropriate in
low bandwidth situations, especially coupled with frame differencing.

Currently, MIDAS's compressors are hardcoded. Only temporal
differencing, RLE, and gzip are supported. Once Merlot is sufficiently developed, MIDAS will be
adapted to use its more flexible image transport mechanisms.

Current Status and Download

MIDAS is currently under active development. The current 0.8.8
version is very usable, and has been demonstrated to work well in a
number of environments.