diff --git a/kiln/Adafruit_I2C.py b/kiln/Adafruit_I2C.py
new file mode 100755
index 0000000..ba81def
--- /dev/null
+++ b/kiln/Adafruit_I2C.py
@@ -0,0 +1,154 @@
+#!/usr/bin/python
+
+import smbus
+
+# ===========================================================================
+# Adafruit_I2C Class
+# ===========================================================================
+
+class Adafruit_I2C(object):
+
+  @staticmethod
+  def getPiRevision():
+    "Gets the version number of the Raspberry Pi board"
+    # Courtesy quick2wire-python-api
+    # https://github.com/quick2wire/quick2wire-python-api
+    # Updated revision info from: http://elinux.org/RPi_HardwareHistory#Board_Revision_History
+    try:
+      with open('/proc/cpuinfo','r') as f:
+        for line in f:
+          if line.startswith('Revision'):
+            return 1 if line.rstrip()[-1] in ['2','3'] else 2
+    except:
+      return 0
+
+  @staticmethod
+  def getPiI2CBusNumber():
+    # Gets the I2C bus number /dev/i2c#
+    return 1 if Adafruit_I2C.getPiRevision() > 1 else 0
+
+  def __init__(self, address, busnum=-1, debug=False):
+    self.address = address
+    # By default, the correct I2C bus is auto-detected using /proc/cpuinfo
+    # Alternatively, you can hard-code the bus version below:
+    # self.bus = smbus.SMBus(0); # Force I2C0 (early 256MB Pi's)
+    # self.bus = smbus.SMBus(1); # Force I2C1 (512MB Pi's)
+    self.bus = smbus.SMBus(busnum if busnum >= 0 else Adafruit_I2C.getPiI2CBusNumber())
+    self.debug = debug
+
+  def reverseByteOrder(self, data):
+    "Reverses the byte order of an int (16-bit) or long (32-bit) value"
+    # Courtesy Vishal Sapre
+    byteCount = len(hex(data)[2:].replace('L','')[::2])
+    val       = 0
+    for i in range(byteCount):
+      val    = (val << 8) | (data & 0xff)
+      data >>= 8
+    return val
+
+  def errMsg(self):
+    print "Error accessing 0x%02X: Check your I2C address" % self.address
+    return -1
+
+  def write8(self, reg, value):
+    "Writes an 8-bit value to the specified register/address"
+    try:
+      self.bus.write_byte_data(self.address, reg, value)
+      if self.debug:
+        print "I2C: Wrote 0x%02X to register 0x%02X" % (value, reg)
+    except IOError, err:
+      return self.errMsg()
+
+  def write16(self, reg, value):
+    "Writes a 16-bit value to the specified register/address pair"
+    try:
+      self.bus.write_word_data(self.address, reg, value)
+      if self.debug:
+        print ("I2C: Wrote 0x%02X to register pair 0x%02X,0x%02X" %
+         (value, reg, reg+1))
+    except IOError, err:
+      return self.errMsg()
+
+  def writeRaw8(self, value):
+    "Writes an 8-bit value on the bus"
+    try:
+      self.bus.write_byte(self.address, value)
+      if self.debug:
+        print "I2C: Wrote 0x%02X" % value
+    except IOError, err:
+      return self.errMsg()
+
+  def writeList(self, reg, list):
+    "Writes an array of bytes using I2C format"
+    try:
+      if self.debug:
+        print "I2C: Writing list to register 0x%02X:" % reg
+        print list
+      self.bus.write_i2c_block_data(self.address, reg, list)
+    except IOError, err:
+      return self.errMsg()
+
+  def readList(self, reg, length):
+    "Read a list of bytes from the I2C device"
+    try:
+      results = self.bus.read_i2c_block_data(self.address, reg, length)
+      if self.debug:
+        print ("I2C: Device 0x%02X returned the following from reg 0x%02X" %
+         (self.address, reg))
+        print results
+      return results
+    except IOError, err:
+      return self.errMsg()
+
+  def readU8(self, reg):
+    "Read an unsigned byte from the I2C device"
+    try:
+      result = self.bus.read_byte_data(self.address, reg)
+      if self.debug:
+        print ("I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" %
+         (self.address, result & 0xFF, reg))
+      return result
+    except IOError, err:
+      return self.errMsg()
+
+  def readS8(self, reg):
+    "Reads a signed byte from the I2C device"
+    try:
+      result = self.bus.read_byte_data(self.address, reg)
+      if result > 127: result -= 256
+      if self.debug:
+        print ("I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" %
+         (self.address, result & 0xFF, reg))
+      return result
+    except IOError, err:
+      return self.errMsg()
+
+  def readU16(self, reg, little_endian=True):
+    "Reads an unsigned 16-bit value from the I2C device"
+    try:
+      result = self.bus.read_word_data(self.address,reg)
+      # Swap bytes if using big endian because read_word_data assumes little 
+      # endian on ARM (little endian) systems.
+      if not little_endian:
+        result = ((result << 8) & 0xFF00) + (result >> 8)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%04X from reg 0x%02X" % (self.address, result & 0xFFFF, reg)
+      return result
+    except IOError, err:
+      return self.errMsg()
+
+  def readS16(self, reg, little_endian=True):
+    "Reads a signed 16-bit value from the I2C device"
+    try:
+      result = self.readU16(reg,little_endian)
+      if result > 32767: result -= 65536
+      return result
+    except IOError, err:
+      return self.errMsg()
+
+if __name__ == '__main__':
+  try:
+    bus = Adafruit_I2C(address=0)
+    print "Default I2C bus is accessible"
+  except:
+    print "Error accessing default I2C bus"
diff --git a/kiln/Adafruit_LEDBackpack.py b/kiln/Adafruit_LEDBackpack.py
new file mode 100644
index 0000000..b2a2006
--- /dev/null
+++ b/kiln/Adafruit_LEDBackpack.py
@@ -0,0 +1,93 @@
+#!/usr/bin/python
+
+import time
+from copy import copy
+from Adafruit_I2C import Adafruit_I2C
+
+# ============================================================================
+# LEDBackpack Class
+# ============================================================================
+
+class LEDBackpack:
+  i2c = None
+
+  # Registers
+  __HT16K33_REGISTER_DISPLAY_SETUP        = 0x80
+  __HT16K33_REGISTER_SYSTEM_SETUP         = 0x20
+  __HT16K33_REGISTER_DIMMING              = 0xE0
+
+  # Blink rate
+  __HT16K33_BLINKRATE_OFF                 = 0x00
+  __HT16K33_BLINKRATE_2HZ                 = 0x01
+  __HT16K33_BLINKRATE_1HZ                 = 0x02
+  __HT16K33_BLINKRATE_HALFHZ              = 0x03
+
+  # Display buffer (8x16-bits)
+  __buffer = [0x0000, 0x0000, 0x0000, 0x0000, \
+              0x0000, 0x0000, 0x0000, 0x0000 ]
+
+  # Constructor
+  def __init__(self, address=0x70, debug=False):
+    self.i2c = Adafruit_I2C(address)
+    self.address = address
+    self.debug = debug
+
+    # Turn the oscillator on
+    self.i2c.write8(self.__HT16K33_REGISTER_SYSTEM_SETUP | 0x01, 0x00)
+
+    # Turn blink off
+    self.setBlinkRate(self.__HT16K33_BLINKRATE_OFF)
+
+    # Set maximum brightness
+    self.setBrightness(15)
+
+    # Clear the screen
+    self.clear()
+
+  def setBrightness(self, brightness):
+    "Sets the brightness level from 0..15"
+    if (brightness > 15):
+      brightness = 15
+    self.i2c.write8(self.__HT16K33_REGISTER_DIMMING | brightness, 0x00)
+
+  def setBlinkRate(self, blinkRate):
+    "Sets the blink rate"
+    if (blinkRate > self.__HT16K33_BLINKRATE_HALFHZ):
+       blinkRate = self.__HT16K33_BLINKRATE_OFF
+    self.i2c.write8(self.__HT16K33_REGISTER_DISPLAY_SETUP | 0x01 | (blinkRate << 1), 0x00)
+
+  def setBufferRow(self, row, value, update=True):
+    "Updates a single 16-bit entry in the 8*16-bit buffer"
+    if (row > 7):
+      return                    # Prevent buffer overflow
+    self.__buffer[row] = value  # value # & 0xFFFF
+    if (update):
+      self.writeDisplay()       # Update the display
+
+  def getBufferRow(self, row):
+    "Returns a single 16-bit entry in the 8*16-bit buffer"
+    if (row > 7):
+      return
+    return self.__buffer[row]
+
+  def getBuffer(self):
+    "Returns a copy of the raw buffer contents"
+    bufferCopy = copy(self.__buffer)
+    return bufferCopy
+ 
+  def writeDisplay(self):
+    "Updates the display memory"
+    bytes = []
+    for item in self.__buffer:
+      bytes.append(item & 0xFF)
+      bytes.append((item >> 8) & 0xFF)
+    self.i2c.writeList(0x00, bytes)
+
+  def clear(self, update=True):
+    "Clears the display memory"
+    self.__buffer = [ 0, 0, 0, 0, 0, 0, 0, 0 ]
+    if (update):
+      self.writeDisplay()
+
+led = LEDBackpack(0x70)
+
diff --git a/kiln/Adafruit_alphanumeric.py b/kiln/Adafruit_alphanumeric.py
new file mode 100644
index 0000000..da249ab
--- /dev/null
+++ b/kiln/Adafruit_alphanumeric.py
@@ -0,0 +1,196 @@
+#!/usr/bin/python
+import threading
+import time
+import datetime
+from Adafruit_LEDBackpack import LEDBackpack
+
+# ===========================================================================
+# Alphanumeric Display
+# ===========================================================================
+
+# This class is meant to be used with the 4-character alphanumeric
+# displays available from Adafruit
+
+class Alphanumeric(object):
+  disp = None
+ 
+  # Hexadecimal character lookup table
+  lut = [
+0b0000000000000001,
+0b0000000000000010,
+0b0000000000000100,
+0b0000000000001000,
+0b0000000000010000,
+0b0000000000100000,
+0b0000000001000000,
+0b0000000010000000,
+0b0000000100000000,
+0b0000001000000000,
+0b0000010000000000,
+0b0000100000000000,
+0b0001000000000000,
+0b0010000000000000,
+0b0100000000000000,
+0b1000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0000000000000000,
+0b0001001011001001,
+0b0001010111000000,
+0b0001001011111001,
+0b0000000011100011,
+0b0000010100110000,
+0b0001001011001000,
+0b0011101000000000,
+0b0001011100000000,
+0b0000000000000000, #
+0b0000000000000110, # !
+0b0000001000100000, # "
+0b0001001011001110, # #
+0b0001001011101101, # $
+0b0000110000100100, # %
+0b0010001101011101, # &
+0b0000010000000000, # '
+0b0010010000000000, # (
+0b0000100100000000, # )
+0b0011111111000000, # *
+0b0001001011000000, # +
+0b0000100000000000, # ,
+0b0000000011000000, # -
+0b0000000000000000, # .
+0b0000110000000000, # /
+0b0000110000111111, # 0
+0b0000000000000110, # 1
+0b0000000011011011, # 2
+0b0000000010001111, # 3
+0b0000000011100110, # 4
+0b0010000001101001, # 5
+0b0000000011111101, # 6
+0b0000000000000111, # 7
+0b0000000011111111, # 8
+0b0000000011101111, # 9
+0b0001001000000000, # :
+0b0000101000000000, # ;
+0b0010010000000000, # <
+0b0000000011001000, # =
+0b0000100100000000, # >
+0b0001000010000011, # ?
+0b0000001010111011, # @
+0b0000000011110111, # A
+0b0001001010001111, # B
+0b0000000000111001, # C
+0b0001001000001111, # D
+0b0000000011111001, # E
+0b0000000001110001, # F
+0b0000000010111101, # G
+0b0000000011110110, # H
+0b0001001000000000, # I
+0b0000000000011110, # J
+0b0010010001110000, # K
+0b0000000000111000, # L
+0b0000010100110110, # M
+0b0010000100110110, # N
+0b0000000000111111, # O
+0b0000000011110011, # P
+0b0010000000111111, # Q
+0b0010000011110011, # R
+0b0000000011101101, # S
+0b0001001000000001, # T
+0b0000000000111110, # U
+0b0000110000110000, # V
+0b0010100000110110, # W
+0b0010110100000000, # X
+0b0001010100000000, # Y
+0b0000110000001001, # Z
+0b0000000000111001, # [
+0b0010000100000000, #
+0b0000000000001111, # ]
+0b0000110000000011, # ^
+0b0000000000001000, # _
+0b0000000100000000, # `
+0b0001000001011000, # a
+0b0010000001111000, # b
+0b0000000011011000, # c
+0b0000100010001110, # d
+0b0000100001011000, # e
+0b0000000001110001, # f
+0b0000010010001110, # g
+0b0001000001110000, # h
+0b0001000000000000, # i
+0b0000000000001110, # j
+0b0011011000000000, # k
+0b0000000000110000, # l
+0b0001000011010100, # m
+0b0001000001010000, # n
+0b0000000011011100, # o
+0b0000000101110000, # p
+0b0000010010000110, # q
+0b0000000001010000, # r
+0b0010000010001000, # s
+0b0000000001111000, # t
+0b0000000000011100, # u
+0b0010000000000100, # v
+0b0010100000010100, # w
+0b0010100011000000, # x
+0b0010000000001100, # y
+0b0000100001001000, # z
+0b0000100101001001, # {
+0b0001001000000000, # |
+0b0010010010001001, # }
+0b0000010100100000, # ~
+0b0011111111111111]
+    
+  special = dict(degree= 0b0000000011100011, cone=0b0010100000001000)
+  
+  # Constructor
+  def __init__(self, address=0x70, debug=False):
+    self.disp = LEDBackpack(address=address, debug=debug)
+
+  def writeCharRaw(self, charNumber, value):
+    "Sets a digit using the raw 16-bit value"
+    if (charNumber > 4):
+      return
+    # Set the appropriate digit
+    self.disp.setBufferRow(charNumber, value)
+
+  def writeChar(self, charNumber, value, dot=False):
+    "Sets a single decimal or hexademical value (0..9 and A..F)"
+    if (charNumber > 4):
+      return
+    if value in special:
+      value = self.special[value]
+    else:
+      value = self.lut[ord(value)]
+    # Set the appropriate digit
+    self.disp.setBufferRow(charNumber, value | (dot << 14))
+
+class AlphaScoller(threading.Thread):
+    def __init__(self, address=0x70, interval=.25):
+        self.interval = interval
+        self.disp = Alphanumeric(address)
+        super(AlphaScroller, self).__init__()
+        self.value = "    "
+    
+    def set_text(self, text, pad=True):
+        self.text = text
+        if pad:
+            self.text += "   "
+        self.counter = 0
+    
+    def set_speed(self, interval):
+        self.interval = interval
+    
+    def run(self):
+        counter = 0
+        while True:
+            for i in range(4):
+                char = self.value[(counter+i) % len(self.value)]
+                self.disp.writeChar(i, char)
+            time.sleep(interval)
+            counter += 1
+
diff --git a/kiln/manager.py b/kiln/manager.py
new file mode 100644
index 0000000..a862b68
--- /dev/null
+++ b/kiln/manager.py
@@ -0,0 +1,3 @@
+from Adafruit_alphanumeric import AlphaScroller
+from stepper import Regulator
+