diff --git a/lib/loader/loader.js b/lib/loader/loader.js
index 99a0295..01839a6 100644
--- a/lib/loader/loader.js
+++ b/lib/loader/loader.js
@@ -43,11 +43,11 @@ var loader, define, requireModule, require, requirejs;
     requirejs: requirejs
   };
 
-  requirejs = require = requireModule = function(name) {
+  requirejs = require = requireModule = function(id) {
     var token = heimdall.start('require');
     heimdall.increment(__require);
     var pending = [];
-    var mod = findModule(name, '(require)', pending);
+    var mod = findModule(id, '(require)', pending);
 
     for (var i = pending.length - 1; i >= 0; i--) {
       pending[i].exports();
@@ -80,16 +80,16 @@ var loader, define, requireModule, require, requirejs;
   var uuid = 0;
 
   function unsupportedModule(length) {
-    throw new Error('an unsupported module was defined, expected `define(name, deps, module)` instead got: `' +
+    throw new Error('an unsupported module was defined, expected `define(id, deps, module)` instead got: `' +
                     length + '` arguments to define`');
   }
 
   var defaultDeps = ['require', 'exports', 'module'];
 
-  function Module(name, deps, callback, alias) {
+  function Module(id, deps, callback, alias) {
     heimdall.increment(modules);
-    this.id        = uuid++;
-    this.name      = name;
+    this.uuid      = uuid++;
+    this.id        = id;
     this.deps      = !deps.length && callback.length ? defaultDeps : deps;
     this.module    = { exports: {} };
     this.callback  = callback;
@@ -126,7 +126,7 @@ var loader, define, requireModule, require, requirejs;
     heimdall.increment(__exports);
 
     if (loader.wrapModules) {
-      this.callback = loader.wrapModules(this.name, this.callback);
+      this.callback = loader.wrapModules(this.id, this.callback);
     }
 
     this.reify();
@@ -191,28 +191,28 @@ var loader, define, requireModule, require, requirejs;
       } else if (dep === 'module') {
         entry.exports = this.module;
       } else {
-        entry.module = findModule(resolve(dep, this.name), this.name, pending);
+        entry.module = findModule(resolve(dep, this.id), this.id, pending);
       }
     }
   };
 
   Module.prototype.makeRequire = function() {
-    var name = this.name;
+    var id = this.id;
     var r = function(dep) {
-      return require(resolve(dep, name));
+      return require(resolve(dep, id));
     };
     r['default'] = r;
-    r.moduleId = name;
+    r.moduleId = id;
     r.has = function(dep) {
-      return has(resolve(dep, name));
+      return has(resolve(dep, id));
     };
     return r;
   };
 
-  define = function(name, deps, callback) {
-    var module = registry[name];
+  define = function(id, deps, callback) {
+    var module = registry[id];
 
-    // If a module for this name has already been defined and is in any state
+    // If a module for this id has already been defined and is in any state
     // other than `new` (meaning it has been or is currently being required),
     // then we return early to avoid redefinition.
     if (module && module.state !== 'new') {
@@ -231,9 +231,9 @@ var loader, define, requireModule, require, requirejs;
     }
 
     if (callback instanceof Alias) {
-      registry[name] = new Module(callback.name, deps, callback, true);
+      registry[id] = new Module(callback.id, deps, callback, true);
     } else {
-      registry[name] = new Module(name, deps, callback, false);
+      registry[id] = new Module(id, deps, callback, false);
     }
     heimdall.stop(token);
   };
@@ -241,31 +241,31 @@ var loader, define, requireModule, require, requirejs;
   // we don't support all of AMD
   // define.amd = {};
 
-  function Alias(path) {
-    this.name = path;
+  function Alias(id) {
+    this.id = id;
   }
 
-  define.alias = function(path, target) {
+  define.alias = function(id, target) {
     if (arguments.length === 2) {
-      return define(target, new Alias(path));
+      return define(target, new Alias(id));
     }
 
-    return new Alias(path);
+    return new Alias(id);
   };
 
-  function missingModule(name, referrer) {
-    throw new Error('Could not find module `' + name + '` imported from `' + referrer + '`');
+  function missingModule(id, referrer) {
+    throw new Error('Could not find module `' + id + '` imported from `' + referrer + '`');
   }
 
-  function findModule(name, referrer, pending) {
+  function findModule(id, referrer, pending) {
     heimdall.increment(__findModule);
-    var mod = registry[name] || registry[name + '/index'];
+    var mod = registry[id] || registry[id + '/index'];
 
     while (mod && mod.isAlias) {
-      mod = registry[mod.name];
+      mod = registry[mod.id];
     }
 
-    if (!mod) { missingModule(name, referrer); }
+    if (!mod) { missingModule(id, referrer); }
 
     if (pending && mod.state !== 'pending' && mod.state !== 'finalized') {
       mod.findDeps(pending);
@@ -275,13 +275,13 @@ var loader, define, requireModule, require, requirejs;
     return mod;
   }
 
-  function resolve(child, name) {
+  function resolve(child, id) {
     heimdall.increment(__resolve);
     if (child.charAt(0) !== '.') { return child; }
     heimdall.increment(resolveRelative);
 
     var parts = child.split('/');
-    var nameParts = name.split('/');
+    var nameParts = id.split('/');
     var parentBase = nameParts.slice(0, -1);
 
     for (var i = 0, l = parts.length; i < l; i++) {
@@ -300,14 +300,14 @@ var loader, define, requireModule, require, requirejs;
     return parentBase.join('/');
   }
 
-  function has(name) {
-    return !!(registry[name] || registry[name + '/index']);
+  function has(id) {
+    return !!(registry[id] || registry[id + '/index']);
   }
 
   requirejs.entries = requirejs._eak_seen = registry;
   requirejs.has = has;
-  requirejs.unsee = function(moduleName) {
-    findModule(moduleName, '(unsee)', false).unsee();
+  requirejs.unsee = function(id) {
+    findModule(id, '(unsee)', false).unsee();
   };
 
   requirejs.clear = function() {
diff --git a/tests/all.js b/tests/all.js
index e2e7a88..eb45edf 100644
--- a/tests/all.js
+++ b/tests/all.js
@@ -8,8 +8,8 @@ var tree;
 /**
  * Simple helper to get the current state of a given module.
  */
-function getModuleState(name) {
-  return requirejs.entries[name].state;
+function getModuleState(id) {
+  return requirejs.entries[id].state;
 }
 
 function statsForMonitor(monitor, tree) {
@@ -811,7 +811,7 @@ test('provides good error message when an un-named AMD module is provided', func
     define(function() {
 
     });
-  }, new Error('an unsupported module was defined, expected `define(name, deps, module)` instead got: `1` arguments to define`'));
+  }, new Error('an unsupported module was defined, expected `define(id, deps, module)` instead got: `1` arguments to define`'));
 });
 
 
@@ -1416,7 +1416,7 @@ test('alias chaining with relative deps works', function() {
 test('wrapModules is called when present', function() {
   var fooCalled = 0;
   var annotatorCalled = 0;
-  loader.wrapModules = function(name, callback) {
+  loader.wrapModules = function(id, callback) {
     annotatorCalled++;
     return callback;
   };