diff --git a/README.md b/README.md
index f5ea1a9..1ea11e2 100644
--- a/README.md
+++ b/README.md
@@ -8,44 +8,68 @@ The core of [gl-shader](https://github.com/mikolalysenko/gl-shader), without the
     
 ## API
 
-### `var shader = require("gl-shader-core")(gl, vertexSource, fragmentSource, uniforms, attributes)`
-Constructs a packaged gl-shader object with shims for all of the uniforms and attributes in the program.
+```javascript
+var createShader = require('gl-shader-core')
+```
+
+### Constructor
+
+There are two main usages for the constructor.  First,
+
+#### `var shader = createShader(vertexSource, fragmentSource[, uniforms, attributes])`
+
+Constructs a wrapped shader object with shims for all of the uniforms and attributes in the program.
 
 * `gl` is the webgl context in which the program will be created
 * `vertexSource` is the source code for the vertex shader
 * `fragmentSource` is the source code for the fragment shader
-* `uniforms` is a list of all uniforms exported by the shader program
-* `attributes` is a list of all attributes exported by the shader program
+* `uniforms` is an (optional) list of all uniforms exported by the shader program
+* `attributes` is an (optional) list of all attributes exported by the shader program
 
-The uniform and attributes variables have output which is consistent with [glsl-extract](https://npmjs.org/package/glsl-extract). 
+The format of `uniforms` and `attributes` is consistent with `glslify`'s output
 
 **Returns** A compiled shader object.
 
 You can specify a default `location` number for each attribute, otherwise WebGL will bind it automatically. 
 
-## Methods
+#### `var shader = createShader(gl, glslifyResult)`
+
+Constructs a shader object from the output of `glslify`.
 
-### `shader.bind()`
+* `gl` is a WebGL context
+* `glslify` is the output of `glslify`
+
+**Returns** A wrapped shader object
+
+### Methods
+
+#### `shader.bind()`
 Binds the shader for rendering
 
-### `shader.dispose()`
+#### `shader.update(vertSource, fragSource[, uniforms, attributes])`
+Rebuilds the shader object with new vertex and fragment shaders (same behavior as constructor)
+
+#### `shader.update(glslifyResult)`
+Rebuilds the shader object with new vertex and fragment shaders (same behavior as constructor)
+
+#### `shader.dispose()`
 Deletes the shader program and associated resources.
 
-## Properties
+### Properties
 
-### `gl`
+#### `gl`
 The WebGL context associated to the shader
 
-### `handle`
-A handle to the underlying WebGL program object
+#### `program`
+A reference to the underlying program object in the WebGL context
 
-### `vertexShader`
-A handle to the underlying WebGL fragment shader object
+#### `vertShader`
+A reference to the underlying vertex shader object
 
-### `fragmentShader`
-A handle to the underlying WebGL vertex shader object
+#### `fragShader`
+A reference to the underlying fragment shader object
 
-## Uniforms
+### Uniforms
 The uniforms for the shader program are packaged up as properties in the `shader.uniforms` object.  For example, to update a scalar uniform you can just assign to it:
 
 ```javascript
@@ -81,11 +105,11 @@ Struct uniforms can also be accessed using the normal dot property syntax.  For
 shader.uniforms.light[0].color = [1, 0, 0, 1]
 ```
 
-## Attributes
+### Attributes
 
 The basic idea behind the attribute interface is similar to that for uniforms, however because attributes can be either a constant value or get values from a vertex array they have a slightly more complicated interface.  All of the attributes are stored in the `shader.attributes` property.
 
-### `attrib = constant`
+#### `attrib = constant`
 For non-array attributes you can set the constant value to be broadcast across all vertices.  For example, to set the vertex color of a shader to a constant you could do:
 
 ```javascript
@@ -107,9 +131,7 @@ Or you can read the currently bound location back by just accessing it:
 console.log(attrib.location)
 ```
 
-Internally, these methods just call [`gl.bindAttribLocation`](http://www.khronos.org/opengles/sdk/docs/man/xhtml/glBindAttribLocation.xml) and access the stored location.
-
-**WARNING** Changing the attribute location requires recompiling the program.  Do not dynamically modify this variable in your render loop.
+**WARNING** Changing the attribute location requires recompiling the program. This recompilation is deferred until the next call to `.bind()`
 
 ### `attrib.pointer([type, normalized, stride, offset])`
 A shortcut for `gl.vertexAttribPointer`/`gl.enableVertexAttribArray`.  See the [OpenGL man page for details on how this works](http://www.khronos.org/opengles/sdk/docs/man/xhtml/glVertexAttribPointer.xml).  The main difference here is that the WebGL context, size and index are known and so these parameters are bound.
@@ -119,7 +141,7 @@ A shortcut for `gl.vertexAttribPointer`/`gl.enableVertexAttribArray`.  See the [
 * `stride` the byte offset between consecutive generic vertex attributes.  (Default: `0`)
 * `offset` offset of the first element of the array in bytes. (Default `0`)
 
-## Reflection
+### Reflection
 
 Finally, the library supports some reflection capabilities.  The set of all uniforms and data types are stored in the "type" property of the shader object,
 
@@ -129,6 +151,5 @@ console.log(shader.types)
 
 This reflects the uniform and attribute parameters that were passed to the shader constructor.
 
-
 ## Credits
-(c) 2013 Mikola Lysenko. MIT License
\ No newline at end of file
+(c) 2013-2014 Mikola Lysenko. MIT License
\ No newline at end of file
diff --git a/lib/create-attributes.js b/lib/create-attributes.js
index 1806bbd..1efb93a 100644
--- a/lib/create-attributes.js
+++ b/lib/create-attributes.js
@@ -2,42 +2,66 @@
 
 module.exports = createAttributeWrapper
 
-//Shader attribute class
-function ShaderAttribute(gl, program, location, dimension, name, constFunc, relink) {
-  this._gl = gl
-  this._program = program
-  this._location = location
+function ShaderAttribute(
+    gl
+  , wrapper
+  , index
+  , locations
+  , dimension) {
+  this._gl        = gl
+  this._wrapper   = wrapper
+  this._index     = index
+  this._locations = locations
   this._dimension = dimension
-  this._name = name
-  this._constFunc = constFunc
-  this._relink = relink
 }
 
 var proto = ShaderAttribute.prototype
 
-proto.pointer = function setAttribPointer(type, normalized, stride, offset) {
-  var gl = this._gl
-  gl.vertexAttribPointer(this._location, this._dimension, type||gl.FLOAT, !!normalized, stride||0, offset||0)
-  this._gl.enableVertexAttribArray(this._location)
+proto.pointer = function setAttribPointer(
+    type
+  , normalized
+  , stride
+  , offset) {
+
+  var self      = this
+  var gl        = self._gl
+  var location  = self._locations[self._index]
+
+  gl.vertexAttribPointer(
+      location
+    , self._dimension
+    , type || gl.FLOAT
+    , !!normalized
+    , stride || 0
+    , offset || 0)
+
+  this._gl.enableVertexAttribArray(location)
 }
 
 Object.defineProperty(proto, 'location', {
   get: function() {
-    return this._location
+    return this._locations[this._index]
   }
   , set: function(v) {
-    if(v !== this._location) {
-      this._location = v
-      this._gl.bindAttribLocation(this._program, v, this._name)
-      this._gl.linkProgram(this._program)
-      this._relink()
+    if(v !== this._locations[this._index]) {
+      this._locations[this._index] = v
+      this._wrapper.program = null
     }
   }
 })
 
 
 //Adds a vector attribute to obj
-function addVectorAttribute(gl, program, location, dimension, obj, name, doLink) {
+function addVectorAttribute(
+    gl
+  , wrapper
+  , index
+  , locations
+  , dimension
+  , obj
+  , name) {
+
+  //Construct constant function
   var constFuncArgs = [ 'gl', 'v' ]
   var varNames = []
   for(var i=0; i<dimension; ++i) {
@@ -45,14 +69,28 @@ function addVectorAttribute(gl, program, location, dimension, obj, name, doLink)
     varNames.push('x'+i)
   }
   constFuncArgs.push([
-    'if(x0.length===void 0){return gl.vertexAttrib', dimension, 'f(v,', varNames.join(), ')}else{return gl.vertexAttrib', dimension, 'fv(v,x0)}'
+    'if(x0.length===void 0){return gl.vertexAttrib'
+    , dimension, 'f(v,'
+    , varNames.join()
+    , ')}else{return gl.vertexAttrib'
+    , dimension
+    , 'fv(v,x0)}'
   ].join(''))
-  var constFunc = Function.apply(undefined, constFuncArgs)
-  var attr = new ShaderAttribute(gl, program, location, dimension, name, constFunc, doLink)
+  var constFunc = Function.apply(null, constFuncArgs)
+
+  //Create attribute wrapper
+  var attr = new ShaderAttribute(
+      gl
+    , wrapper
+    , index
+    , locations
+    , dimension)
+
+  //Create accessor
   Object.defineProperty(obj, name, {
     set: function(x) {
-      gl.disableVertexAttribArray(attr._location)
-      constFunc(gl, attr._location, x)
+      gl.disableVertexAttribArray(locations[index])
+      constFunc(gl, locations[index], x)
       return x
     }
     , get: function() {
@@ -63,19 +101,31 @@ function addVectorAttribute(gl, program, location, dimension, obj, name, doLink)
 }
 
 //Create shims for attributes
-function createAttributeWrapper(gl, program, attributes, doLink) {
+function createAttributeWrapper(
+    gl
+  , wrapper
+  , attributes
+  , locations) {
+
   var obj = {}
   for(var i=0, n=attributes.length; i<n; ++i) {
+
     var a = attributes[i]
     var name = a.name
     var type = a.type
-    var location = gl.getAttribLocation(program, name)
     
     switch(type) {
       case 'bool':
       case 'int':
       case 'float':
-        addVectorAttribute(gl, program, location, 1, obj, name, doLink)
+        addVectorAttribute(
+            gl
+          , wrapper
+          , i
+          , locations
+          , 1
+          , obj
+          , name)
       break
       
       default:
@@ -84,7 +134,14 @@ function createAttributeWrapper(gl, program, attributes, doLink) {
           if(d < 2 || d > 4) {
             throw new Error('gl-shader: Invalid data type for attribute ' + name + ': ' + type)
           }
-          addVectorAttribute(gl, program, location, d, obj, name, doLink)
+          addVectorAttribute(
+              gl
+            , wrapper
+            , i
+            , locations
+            , d
+            , obj
+            , name)
         } else {
           throw new Error('gl-shader: Unknown data type for attribute ' + name + ': ' + type)
         }
diff --git a/lib/create-uniforms.js b/lib/create-uniforms.js
index 8185354..fc82ee4 100644
--- a/lib/create-uniforms.js
+++ b/lib/create-uniforms.js
@@ -12,12 +12,15 @@ function identity(x) {
 }
 
 //Create shims for uniforms
-function createUniformWrapper(gl, program, uniforms, locations) {
+function createUniformWrapper(gl, wrapper, uniforms, locations) {
 
   function makeGetter(index) {
-    var proc = new Function('gl', 'prog', 'locations', 
-      'return function(){return gl.getUniform(prog,locations[' + index + '])}') 
-    return proc(gl, program, locations)
+    var proc = new Function(
+        'gl'
+      , 'wrapper'
+      , 'locations'
+      , 'return function(){return gl.getUniform(wrapper.program,locations[' + index + '])}') 
+    return proc(gl, wrapper, locations)
   }
 
   function makePropSetter(path, index, type) {
@@ -92,8 +95,8 @@ function createUniformWrapper(gl, program, uniforms, locations) {
       }
     }
     code.push('return obj}')
-    var proc = new Function('gl', 'prog', 'locations', code.join('\n'))
-    return proc(gl, program, locations)
+    var proc = new Function('gl', 'locations', code.join('\n'))
+    return proc(gl, locations)
   }
 
   function defaultValue(type) {
diff --git a/lib/runtime-reflect.js b/lib/runtime-reflect.js
new file mode 100644
index 0000000..f7f7d13
--- /dev/null
+++ b/lib/runtime-reflect.js
@@ -0,0 +1,68 @@
+'use strict'
+
+exports.uniforms    = runtimeUniforms
+exports.attributes  = runtimeAttributes
+
+var GL_TO_GLSL_TYPES = {
+  'FLOAT':       'float',
+  'FLOAT_VEC2':  'vec2',
+  'FLOAT_VEC3':  'vec3',
+  'FLOAT_VEC4':  'vec4',
+  'INT':         'int',
+  'INT_VEC2':    'ivec2',
+  'INT_VEC3':    'ivec3',
+  'INT_VEC4':    'ivec4',
+  'BOOL':        'bool',
+  'BOOL_VEC2':   'bvec2',
+  'BOOL_VEC3':   'bvec3',
+  'BOOL_VEC4':   'bvec4',
+  'FLOAT_MAT2':  'mat2',
+  'FLOAT_MAT3':  'mat3',
+  'FLOAT_MAT4':  'mat4',
+  'SAMPLER_2D':  'sampler2D',
+  'SAMPLER_CUBE':'samplerCube'
+}
+
+var GL_TABLE = null
+
+function getType(gl, type) {
+  if(!GL_TABLE) {
+    var typeNames = Object.keys(GL_TO_GLSL_TYPES)
+    GL_TABLE = {}
+    for(var i=0; i<typeNames.length; ++i) {
+      var tn = typeNames[i]
+      GL_TABLE[gl[tn]] = GL_TO_GLSL_TYPES[tn]
+    }
+  }
+  return GL_TABLE[type]
+}
+
+function runtimeUniforms(gl, program) {
+  var numUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS)
+  var result = []
+  for(var i=0; i<numUniforms; ++i) {
+    var info = gl.getActiveUniform(program, i)
+    if(info) {
+      result.push({
+        name: info.name,
+        type: getType(gl, info.type)
+      })
+    }
+  }
+  return result
+}
+
+function runtimeAttributes(gl, program) {
+  var numAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES)
+  var result = []
+  for(var i=0; i<numAttributes; ++i) {
+    var info = gl.getActiveAttrib(program, i)
+    if(info) {
+      result.push({
+        name: info.name,
+        type: getType(gl, info.type)
+      })
+    }
+  }
+  return result
+}
\ No newline at end of file
diff --git a/lib/shader-cache.js b/lib/shader-cache.js
new file mode 100644
index 0000000..45eb415
--- /dev/null
+++ b/lib/shader-cache.js
@@ -0,0 +1,129 @@
+'use strict'
+
+exports.shader   = getShaderReference
+exports.program  = createProgram
+
+var weakMap = typeof WeakMap === 'undefined' ? require('weakmap-shim') : WeakMap
+var CACHE = new weakMap()
+
+var SHADER_COUNTER = 0
+
+function ShaderReference(id, src, type, shader, programs, count, cache) {
+  this.id       = id
+  this.src      = src
+  this.type     = type
+  this.shader   = shader
+  this.count    = count
+  this.programs = []
+  this.cache    = cache
+}
+
+ShaderReference.prototype.dispose = function() {
+  if(--this.count === 0) {
+    var cache    = this.cache
+    var gl       = cache.gl
+    
+    //Remove program references
+    var programs = this.programs
+    for(var i=0, n=programs.length; i<n; ++i) {
+      var p = cache.programs[programs[i]]
+      if(p) {
+        delete cache.programs[i]
+        gl.deleteProgram(p)
+      }
+    }
+
+    //Remove shader reference
+    gl.deleteShader(this.shader)
+    delete cache.shaders[(this.type === gl.FRAGMENT_SHADER)|0][this.src]
+  }
+}
+
+function ContextCache(gl) {
+  this.gl       = gl
+  this.shaders  = [{}, {}]
+  this.programs = {}
+}
+
+var proto = ContextCache.prototype
+
+function compileShader(gl, type, src) {
+  var shader = gl.createShader(type)
+  gl.shaderSource(shader, src)
+  gl.compileShader(shader)
+  if(!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    var errLog = gl.getShaderInfoLog(shader)
+    console.error('gl-shader: Error compiling shader:', errLog)
+    throw new Error('gl-shader: Error compiling shader:' + errLog)
+  }
+  return shader
+}
+
+proto.getShaderReference = function(type, src) {
+  var gl      = this.gl
+  var shaders = this.shaders[(type === gl.FRAGMENT_SHADER)|0]
+  var shader  = shaders[src]
+  if(!shader) {
+    var shaderObj = compileShader(gl, type, src)
+    shader = shaders[src] = new ShaderReference(
+      SHADER_COUNTER++,
+      src,
+      type,
+      shaderObj,
+      [],
+      1,
+      this)
+  } else {
+    shader.count += 1
+  }
+  return shader
+}
+
+function linkProgram(gl, vshader, fshader, attribs, locations) {
+  var program = gl.createProgram()
+  gl.attachShader(program, vshader)
+  gl.attachShader(program, fshader)
+  for(var i=0; i<attribs.length; ++i) {
+    gl.bindAttribLocation(program, locations[i], attribs[i])
+  }
+  gl.linkProgram(program)
+  if(!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    var errLog = gl.getProgramInfoLog(program)
+    console.error('gl-shader: Error linking program:', errLog)
+    throw new Error('gl-shader: Error linking program:' + errLog)
+  }
+  return program
+}
+
+proto.getProgram = function(vref, fref, attribs, locations) {
+  var token = [vref.id, fref.id, attribs.join(':'), locations.join(':')].join('@')
+  var prog  = this.programs[token]
+  if(!prog) {
+    this.programs[token] = prog = linkProgram(
+      this.gl,
+      vref.shader,
+      fref.shader,
+      attribs,
+      locations)
+    vref.programs.push(token)
+    fref.programs.push(token)
+  }
+  return prog
+}
+
+function getCache(gl) {
+  var ctxCache = CACHE.get(gl)
+  if(!ctxCache) {
+    ctxCache = new ContextCache(gl)
+    CACHE.set(gl, ctxCache)
+  }
+  return ctxCache
+}
+
+function getShaderReference(gl, type, src) {
+  return getCache(gl).getShaderReference(type, src)
+}
+
+function createProgram(gl, vref, fref, attribs, locations) {
+  return getCache(gl).getProgram(vref, fref, attribs, locations)
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index fc9fe05..e15c2cd 100644
--- a/package.json
+++ b/package.json
@@ -20,6 +20,7 @@
     "url": "https://github.com/mikolalysenko/gl-shader-core/issues"
   },
   "dependencies": {
-    "dup": "^1.0.0"
+    "dup": "^1.0.0",
+    "weakmap-shim": "^1.1.0"
   }
 }
diff --git a/shader-core.js b/shader-core.js
index ff138d3..f383769 100644
--- a/shader-core.js
+++ b/shader-core.js
@@ -1,71 +1,188 @@
 'use strict'
 
-var createUniformWrapper = require('./lib/create-uniforms')
+var createUniformWrapper   = require('./lib/create-uniforms')
 var createAttributeWrapper = require('./lib/create-attributes')
-var makeReflect = require('./lib/reflect')
+var makeReflect            = require('./lib/reflect')
+var shaderCache            = require('./lib/shader-cache')
+var runtime                = require('./lib/runtime-reflect')
 
 //Shader object
-function Shader(gl, prog, vertShader, fragShader) {
-  this.gl = gl
-  this.handle = prog
-  this.attributes = null
-  this.uniforms = null
-  this.types = null
-  this.vertexShader = vertShader
-  this.fragmentShader = fragShader
+function Shader(gl) {
+  this.gl         = gl
+
+  //Default initialize these to null
+  this._vref      = 
+  this._fref      = 
+  this._relink    =
+  this.vertShader =
+  this.fragShader =
+  this.program    =
+  this.attributes =
+  this.uniforms   =
+  this.types      = null
 }
 
-//Binds the shader
-Shader.prototype.bind = function() {
-  this.gl.useProgram(this.handle)
+var proto = Shader.prototype
+
+proto.bind = function() {
+  if(!this.program) {
+    this._relink()
+  }
+  this.gl.useProgram(this.program)
 }
 
-//Destroy shader, release resources
-Shader.prototype.dispose = function() {
-  var gl = this.gl
-  gl.deleteShader(this.vertexShader)
-  gl.deleteShader(this.fragmentShader)
-  gl.deleteProgram(this.handle)
+proto.dispose = function() {
+  if(this._fref) {
+    this._fref.dispose()
+  }
+  if(this._vref) {
+    this._vref.dispose()
+  }
+  this.attributes =
+  this.types      =
+  this.vertShader =
+  this.fragShader =
+  this.program    = 
+  this._relink    = 
+  this._fref      = 
+  this._vref      = null
 }
 
-Shader.prototype.updateExports = function(uniforms, attributes) {
-  var locations = new Array(uniforms.length)
-  var program = this.handle
-  var gl = this.gl
-
-  var doLink = relinkUniforms.bind(void 0,
-    gl,
-    program,
-    locations,
-    uniforms
-  )
-  doLink()
-
-  this.types = {
-    uniforms: makeReflect(uniforms),
-    attributes: makeReflect(attributes)
+//Update export hook for glslify-live
+proto.update = function(
+    vertSource
+  , fragSource
+  , uniforms
+  , attributes) {
+
+  //If only one object passed, assume glslify style output
+  if(!fragSource || arguments.length === 1) {
+    var obj = vertSource
+    vertSource = obj.vertex
+    fragSource = obj.fragment
+    uniforms   = obj.uniforms
+    attributes = obj.attributes
   }
 
-  this.attributes = createAttributeWrapper(
-    gl,
-    program,
-    attributes,
-    doLink
-  )
-
-  Object.defineProperty(this, 'uniforms', createUniformWrapper(
-    gl,
-    program,
-    uniforms,
-    locations
-  ))
-}
+  var wrapper = this
+  var gl      = wrapper.gl
 
-//Relinks all uniforms
-function relinkUniforms(gl, program, locations, uniforms) {
-  for(var i=0; i<uniforms.length; ++i) {
-    locations[i] = gl.getUniformLocation(program, uniforms[i].name)
+  //Compile vertex and fragment shaders
+  var pvref = wrapper._vref
+  wrapper._vref = shaderCache.shader(gl, gl.VERTEX_SHADER, vertSource)
+  if(pvref) {
+    pvref.dispose()
   }
+  wrapper.vertShader = wrapper._vref.shader
+  var pfref = this._fref
+  wrapper._fref = shaderCache.shader(gl, gl.FRAGMENT_SHADER, fragSource)
+  if(pfref) {
+    pfref.dispose()
+  }
+  wrapper.fragShader = wrapper._fref.shader
+  
+  //If uniforms/attributes is not specified, use RT reflection
+  if(!uniforms || !attributes) {
+
+    //Create initial test program
+    var testProgram = gl.createProgram()
+    gl.attachShader(testProgram, wrapper.fragShader)
+    gl.attachShader(testProgram, wrapper.vertShader)
+    gl.linkProgram(testProgram)
+    if(!gl.getProgramParameter(testProgram, gl.LINK_STATUS)) {
+      var errLog = gl.getProgramInfoLog(testProgram)
+      console.error('gl-shader: Error linking program:', errLog)
+      throw new Error('gl-shader: Error linking program:' + errLog)
+    }
+    
+    //Load data from runtime
+    uniforms   = uniforms   || runtime.uniforms(gl, testProgram)
+    attributes = attributes || runtime.attributes(gl, testProgram)
+
+    //Release test program
+    gl.deleteProgram(testProgram)
+  }
+
+  //Sort attributes lexicographically
+  // overrides undefined WebGL behavior for attribute locations
+  attributes = attributes.slice()
+  attributes.sort(function(a, b) {
+    if(a.name < b.name) {
+      return -1
+    } else if(a.name > b.name) {
+      return 1
+    }
+    return 0
+  })
+
+  //Extract names
+  var attributeNames = attributes.map(function(attr) {
+    return attr.name
+  })
+
+  //Get default location
+  var attributeLocations = attributes.map(function(attr) {
+    if('location' in attr) {
+      return attr.location|0
+    } else {
+      return -1
+    }
+  })
+
+  //For all unspecified attributes, assign them lexicographically min attribute
+  var curLocation = 0
+  for(var i=0; i<attributeLocations.length; ++i) {
+    if(attributeLocations[i] < 0) {
+      while(attributeLocations.indexOf(curLocation) >= 0) {
+        curLocation += 1
+      }
+      attributeLocations[i] = curLocation
+    }
+  }
+
+  //Rebuild program and recompute all uniform locations
+  var uniformLocations = new Array(uniforms.length)
+  function relink(prog) {
+    wrapper.program = shaderCache.program(
+        gl
+      , wrapper._vref
+      , wrapper._fref
+      , attributeNames
+      , attributeLocations
+      , prog)
+
+    for(var i=0; i<uniforms.length; ++i) {
+      uniformLocations[i] = gl.getUniformLocation(
+          wrapper.program
+        , uniforms[i].name)
+    }
+  }
+
+  //Perform initial linking, reuse program used for reflection
+  relink()
+
+  //Save relinking procedure, defer until runtime
+  wrapper._relink = relink
+
+  //Generate type info
+  wrapper.types = {
+    uniforms:   makeReflect(uniforms),
+    attributes: makeReflect(attributes)
+  }
+
+  //Generate attribute wrappers
+  wrapper.attributes = createAttributeWrapper(
+      gl
+    , wrapper
+    , attributes
+    , attributeLocations)
+
+  //Generate uniform wrappers
+  Object.defineProperty(wrapper, 'uniforms', createUniformWrapper(
+      gl
+    , wrapper
+    , uniforms
+    , uniformLocations))
 }
 
 //Compiles and links a shader program with the given attribute and vertex list
@@ -75,55 +192,16 @@ function createShader(
   , fragSource
   , uniforms
   , attributes) {
-  
-  //Compile vertex shader
-  var vertShader = gl.createShader(gl.VERTEX_SHADER)
-  gl.shaderSource(vertShader, vertSource)
-  gl.compileShader(vertShader)
-  if(!gl.getShaderParameter(vertShader, gl.COMPILE_STATUS)) {
-    var errLog = gl.getShaderInfoLog(vertShader)
-    console.error('gl-shader: Error compling vertex shader:', errLog)
-    throw new Error('gl-shader: Error compiling vertex shader:' + errLog)
-  }
-  
-  //Compile fragment shader
-  var fragShader = gl.createShader(gl.FRAGMENT_SHADER)
-  gl.shaderSource(fragShader, fragSource)
-  gl.compileShader(fragShader)
-  if(!gl.getShaderParameter(fragShader, gl.COMPILE_STATUS)) {
-    var errLog = gl.getShaderInfoLog(fragShader)
-    console.error('gl-shader: Error compiling fragment shader:', errLog)
-    throw new Error('gl-shader: Error compiling fragment shader:' + errLog)
-  }
-  
-  //Link program
-  var program = gl.createProgram()
-  gl.attachShader(program, fragShader)
-  gl.attachShader(program, vertShader)
-
-  //Optional default attriubte locations
-  attributes.forEach(function(a) {
-    if (typeof a.location === 'number') 
-      gl.bindAttribLocation(program, a.location, a.name)
-  })
 
-  gl.linkProgram(program)
-  if(!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    var errLog = gl.getProgramInfoLog(program)
-    console.error('gl-shader: Error linking shader program:', errLog)
-    throw new Error('gl-shader: Error linking shader program:' + errLog)
-  }
-  
-  //Return final linked shader object
-  var shader = new Shader(
-    gl,
-    program,
-    vertShader,
-    fragShader
-  )
-  shader.updateExports(uniforms, attributes)
+  var shader = new Shader(gl)
+
+  shader.update(
+      vertSource
+    , fragSource
+    , uniforms
+    , attributes)
 
   return shader
 }
 
-module.exports = createShader
+module.exports = createShader
\ No newline at end of file