ether dream

Ether Dream - User Guide

NOTE - This page is for the previous Ether Dream 1. Check the current website.



Congratulations! Ether Dream is the most flexible, powerful, and open DAC available today. It is designed to enable easy live playback from PC software and to serve as a platform for experimentation and development.

Quick Start

To get started with your Ether Dream, just connect its output to your projector, its Ethernet connection to your network or computer, and then the power supply to a source of 9-25v DC or to the included adapter. The green LED next to the USB connector will light to indicate that power is on, and the yellow LED next to the ILDA connector will light to indicate that the interlock is now closed.

If you're connecting to a home network with a router or DHCP server, no other configuration will be needed - any computer on the network will be able to reach the Ether Dream. If you connect the Ether Dream directly to your computer, make sure that it is set to obtain its IP address automatically.

To make sure that your computer can communicate properly with your Ether Dream, a diagnostic tool is available on the Downloads page.

Note: you may need to disable or adjust the settings on your firewall software to be able to communicate with the Ether Dream. The driver DLL uses TCP port 7765 and UDP port 7654.

LSX, ILD SÔS, and other software using the universal DAC interface library written by drlava have native Ether Dream support. However, a software update may be needed - support was only added to the library in late October 2011. Contact drlava for an updated build of LSX or ILD SÔS. Other software that works with ezauddac.dll can be set up to use an Ether Dream by making a backup of its ezauddac.dll and renaming EtherDream.dll (from the Downloads page) to ezauddac.dll.

Once the driver DLL is installed, just start up the software and the Ether Dream will automatically be detected.


Ether Dream board diagram

Starting at the Ethernet connector on the board and moving counterclockwise, the indicators and connectors on the board are:

Live Playback

Ether Dream supports a standard frame-based API and should work "out of the box" with existing playback software, once drivers are installed.

In the event of a momentary glitch in its data stream, the Ether Dream driver will automatically restart playback. If an Ether Dream unit detects that its network link is physically disconnected, it will go into an 'emergency-stop' mode and stop output until the network is restored.


With an extra adapter board, the expansion connectors on the Ether Dream can transmit and receive DMX signals to interface with lighting equipment. The Ether Dream can simultaneously drive three DMX universes, relaying commands from Ethernet to DMX, and also receive on one universe, sending information from DMX to Ethernet.

Each of the serial expansion headers on the diagram above can connect to a DMX adapter board. The firmware supports both transmitting and receiving DMX from connector #1, and transmitting only from conectors #2 and #3.

DMX output is enabled and controlled with OSC messages. When the Ether Dream receives a message for a given DMX universe, it will enable output for that universe and start continuously sending DMX data to an attached interface board. The DMX output can be controlled in any of several ways:

DMX input is enabled by sending a message with a string and a number to /dmx1/input. The string specifies the IP address (must be a numeric IP address, not a hostname) to relay DMX updates to, and the number is a port number. DMX updates will be sent as OSC messages to /dmx1 containing a single blob - the same format as described above for DMX output.

If the address given is "me" and the port is 0, then messages will be sent back to the same host and port that the /dmx1/input command was received one. If the address is blank and the port is 0, then DMX input will be disabled.

This code will set the first four channels of an Ether Dream's DMX universe 1 to 255:

import liblo
liblo.send(liblo.Address("", 60000), "/dmx1/1", 255, 255, 255, 255)

To receive input over DMX, raw sockets can be used easily:

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto("/dmx1/input\x00,si\x00me\x00\x00\x00\x00\x00\x00", ("", 60000))
while True:
        data, addr = sock.recvfrom(1024) 
        print "DMX channels: %d %d %d %d" % map(ord, data[16:20]))

Or liblo's server functionality can be used instead:

import liblo
class DMXServer(liblo.Server):
        @liblo.make_method('/dmx1', 'b')
        def dmx1_callback(self, channel_blob):
                chanenls = map(ord, channel_blob)
                print "DMX channels: %d %d %d %d" % channels[:4]
server = DMXServer(32123)
liblo.send(liblo.Address("", 60000), "/dmx1/input", "me", 32123)
while True:


The other capabilites of the Ether Dream are accessed via its parameters. Parameters can be set and actions invoked in two ways:

  1. The DAC listens for OSC packets on a UDP port.
  2. On startup, commands are loaded from the autoplay.txt on the SD card, if present.

OSC is a simple UDP-based protocol for sending control messages; it is usually used for audio, to control synthesizers, mixers, etc., but is flexible enough to support laser applications as well. Bridges exist between OSC and MIDI or DMX. An OSC message is sent to an address, like /channel/1/volume or /ilda/pps, and contains some data: zero or more numbers, strings, True/False values, etc.

The Ether Dream listens for OSC messages on UDP port 60000. When it sends a response to a message, it will send that response to port 60001 on the originating host. There are many OSC-handling programs and OSC plugins, as well as libraries for most programming languages, available on the Internet.

Most of the OSC parameter endpoints implemented on the Ether Dream take some sort of data. Those labeled as "integer" or "float" expect a value in the given range. OSC endpoints specified as "message" can be sent a message with either no data or with an integer value, but will ignore the message if the value is zero. This allows them to be controlled by a pushbutton on a control surface that sends OSC messages - a pushbutton will send a nonzero value when it is pressed, and then send 0 when it is released.

As an example, the following autoplay.txt file might be used to play a prerecorded show automatically when the DAC is powered up:

/ilda/pps 30000
/ilda/fps 30
/geom/size 0.3
/geom/offset 0.4 -0.2
/ilda/play show.ild

The following Python code, using liblo, will play the first ILDA file on the SD card:

import liblo
dac = liblo.Address("", 60000)
liblo.send(dac, "/ilda/1/play")

Control layout files for TouchOSC, a third-party iPhone/iPad app, are available in the Ether Dream source repository under the tools/ directory - j4cDAC.touchosc is for iPad, and j4cDAC-phone.touchosc is for iPhone.


The Ether Dream firmware, available on github, builds on a standard Linux system with the free CodeSourcery ARM toolchain. The README in the repository describes the needed tools.