diff --git a/lib/handlebars/base.js b/lib/handlebars/base.js
index 790228c1..2dc2fea6 100644
--- a/lib/handlebars/base.js
+++ b/lib/handlebars/base.js
@@ -70,12 +70,22 @@ function registerDefaultHelpers(instance) {
       return inverse(this);
     } else if (isArray(context)) {
       if(context.length > 0) {
+        if (options.ids) {
+          options.ids = [options.name];
+        }
+
         return instance.helpers.each(context, options);
       } else {
         return inverse(this);
       }
     } else {
-      return fn(context);
+      if (options.data && options.ids) {
+        var data = createFrame(options.data);
+        data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
+        options = {data: data};
+      }
+
+      return fn(context, options);
     }
   });
 
@@ -89,6 +99,11 @@ function registerDefaultHelpers(instance) {
     var fn = options.fn, inverse = options.inverse;
     var i = 0, ret = "", data;
 
+    var contextPath;
+    if (options.data && options.ids) {
+      contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
+    }
+
     if (isFunction(context)) { context = context.call(this); }
 
     if (options.data) {
@@ -102,6 +117,10 @@ function registerDefaultHelpers(instance) {
             data.index = i;
             data.first = (i === 0);
             data.last  = (i === (context.length-1));
+
+            if (contextPath) {
+              data.contextPath = contextPath + i;
+            }
           }
           ret = ret + fn(context[i], { data: data });
         }
@@ -112,6 +131,10 @@ function registerDefaultHelpers(instance) {
               data.key = key;
               data.index = i;
               data.first = (i === 0);
+
+              if (contextPath) {
+                data.contextPath = contextPath + key;
+              }
             }
             ret = ret + fn(context[key], {data: data});
             i++;
@@ -147,7 +170,17 @@ function registerDefaultHelpers(instance) {
   instance.registerHelper('with', function(context, options) {
     if (isFunction(context)) { context = context.call(this); }
 
-    if (!Utils.isEmpty(context)) return options.fn(context);
+    var fn = options.fn;
+
+    if (!Utils.isEmpty(context)) {
+      if (options.data && options.ids) {
+        var data = createFrame(options.data);
+        data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
+        options = {data:data};
+      }
+
+      return fn(context, options);
+    }
   });
 
   instance.registerHelper('log', function(context, options) {
diff --git a/lib/handlebars/compiler/ast.js b/lib/handlebars/compiler/ast.js
index 67898839..5a5f514d 100644
--- a/lib/handlebars/compiler/ast.js
+++ b/lib/handlebars/compiler/ast.js
@@ -149,7 +149,8 @@ var AST = {
 
     var original = "",
         dig = [],
-        depth = 0;
+        depth = 0,
+        depthString = '';
 
     for(var i=0,l=parts.length; i<l; i++) {
       var part = parts[i].part;
@@ -160,6 +161,7 @@ var AST = {
           throw new Exception("Invalid path: " + original, this);
         } else if (part === "..") {
           depth++;
+          depthString += '../';
         } else {
           this.isScoped = true;
         }
@@ -172,6 +174,7 @@ var AST = {
     this.parts    = dig;
     this.string   = dig.join('.');
     this.depth    = depth;
+    this.idName   = depthString + this.string;
 
     // an ID is simple if it only has one part, and that part is not
     // `..` or `this`.
@@ -191,6 +194,7 @@ var AST = {
     this.type = "DATA";
     this.id = id;
     this.stringModeValue = id.stringModeValue;
+    this.idName = '@' + id.stringModeValue;
   },
 
   StringNode: function(string, locInfo) {
diff --git a/lib/handlebars/compiler/compiler.js b/lib/handlebars/compiler/compiler.js
index 3f7aa3bf..cfcc70ac 100644
--- a/lib/handlebars/compiler/compiler.js
+++ b/lib/handlebars/compiler/compiler.js
@@ -74,6 +74,7 @@ Compiler.prototype = {
     this.depths = {list: []};
     this.options = options;
     this.stringParams = options.stringParams;
+    this.trackIds = options.trackIds;
 
     // These changes will propagate to the other compiler components
     var knownHelpers = this.options.knownHelpers;
@@ -395,6 +396,9 @@ Compiler.prototype = {
         this.sexpr(val);
       }
     } else {
+      if (this.trackIds) {
+        this.opcode('pushId', val.type, val.idName || val.stringModeValue);
+      }
       this.accept(val);
     }
   },
diff --git a/lib/handlebars/compiler/javascript-compiler.js b/lib/handlebars/compiler/javascript-compiler.js
index 96a8a0ea..ff6bc476 100644
--- a/lib/handlebars/compiler/javascript-compiler.js
+++ b/lib/handlebars/compiler/javascript-compiler.js
@@ -61,6 +61,7 @@ JavaScriptCompiler.prototype = {
     this.environment = environment;
     this.options = options || {};
     this.stringParams = this.options.stringParams;
+    this.trackIds = this.options.trackIds;
 
     log('debug', this.environment.disassemble() + "\n\n");
 
@@ -418,6 +419,9 @@ JavaScriptCompiler.prototype = {
   emptyHash: function() {
     this.pushStackLiteral('{}');
 
+    if (this.trackIds) {
+      this.push('{}'); // hashIds
+    }
     if (this.stringParams) {
       this.push('{}'); // hashContexts
       this.push('{}'); // hashTypes
@@ -427,12 +431,15 @@ JavaScriptCompiler.prototype = {
     if (this.hash) {
       this.hashes.push(this.hash);
     }
-    this.hash = {values: [], types: [], contexts: []};
+    this.hash = {values: [], types: [], contexts: [], ids: []};
   },
   popHash: function() {
     var hash = this.hash;
     this.hash = this.hashes.pop();
 
+    if (this.trackIds) {
+      this.push('{' + hash.ids.join(',') + '}');
+    }
     if (this.stringParams) {
       this.push('{' + hash.contexts.join(',') + '}');
       this.push('{' + hash.types.join(',') + '}');
@@ -589,8 +596,12 @@ JavaScriptCompiler.prototype = {
   assignToHash: function(key) {
     var value = this.popStack(),
         context,
-        type;
+        type,
+        id;
 
+    if (this.trackIds) {
+      id = this.popStack();
+    }
     if (this.stringParams) {
       type = this.popStack();
       context = this.popStack();
@@ -603,9 +614,22 @@ JavaScriptCompiler.prototype = {
     if (type) {
       hash.types.push("'" + key + "': " + type);
     }
+    if (id) {
+      hash.ids.push("'" + key + "': " + id);
+    }
     hash.values.push("'" + key + "': (" + value + ")");
   },
 
+  pushId: function(type, name) {
+    if (type === 'ID' || type === 'DATA') {
+      this.pushString(name);
+    } else if (type === 'sexpr') {
+      this.pushStackLiteral('true');
+    } else {
+      this.pushStackLiteral('null');
+    }
+  },
+
   // HELPERS
 
   compiler: JavaScriptCompiler,
@@ -844,11 +868,14 @@ JavaScriptCompiler.prototype = {
   },
 
   setupOptions: function(helper, paramSize, params) {
-    var options = {}, contexts = [], types = [], param, inverse, program;
+    var options = {}, contexts = [], types = [], ids = [], param, inverse, program;
 
     options.name = this.quotedString(helper);
     options.hash = this.popStack();
 
+    if (this.trackIds) {
+      options.hashIds = this.popStack();
+    }
     if (this.stringParams) {
       options.hashTypes = this.popStack();
       options.hashContexts = this.popStack();
@@ -878,12 +905,18 @@ JavaScriptCompiler.prototype = {
       param = this.popStack();
       params.push(param);
 
+      if (this.trackIds) {
+        ids.push(this.popStack());
+      }
       if (this.stringParams) {
         types.push(this.popStack());
         contexts.push(this.popStack());
       }
     }
 
+    if (this.trackIds) {
+      options.ids = "[" + ids.join(",") + "]";
+    }
     if (this.stringParams) {
       options.types = "[" + types.join(",") + "]";
       options.contexts = "[" + contexts.join(",") + "]";
diff --git a/lib/handlebars/utils.js b/lib/handlebars/utils.js
index 63148e46..f2f1a547 100644
--- a/lib/handlebars/utils.js
+++ b/lib/handlebars/utils.js
@@ -75,3 +75,7 @@ export function isEmpty(value) {
     return false;
   }
 }
+
+export function appendContextPath(contextPath, id) {
+  return (contextPath ? contextPath + '.' : '') + id;
+}
diff --git a/spec/track-ids.js b/spec/track-ids.js
new file mode 100644
index 00000000..938f98bb
--- /dev/null
+++ b/spec/track-ids.js
@@ -0,0 +1,163 @@
+/*global CompilerContext */
+describe('track ids', function() {
+  var context;
+  beforeEach(function() {
+    context = {is: {a: 'foo'}, slave: {driver: 'bar'}};
+  });
+
+  it('should not include anything without the flag', function() {
+    var template = CompilerContext.compile('{{wycats is.a slave.driver}}');
+
+    var helpers = {
+      wycats: function(passiveVoice, noun, options) {
+        equal(options.ids, undefined);
+        equal(options.hashIds, undefined);
+
+        return 'success';
+      }
+    };
+
+    equals(template({}, {helpers: helpers}), 'success');
+  });
+  it('should include argument ids', function() {
+    var template = CompilerContext.compile('{{wycats is.a slave.driver}}', {trackIds: true});
+
+    var helpers = {
+      wycats: function(passiveVoice, noun, options) {
+        equal(options.ids[0], 'is.a');
+        equal(options.ids[1], 'slave.driver');
+
+        return "HELP ME MY BOSS " + options.ids[0] + ':' + passiveVoice + ' ' + options.ids[1] + ':' + noun;
+      }
+    };
+
+    equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS is.a:foo slave.driver:bar');
+  });
+  it('should include hash ids', function() {
+    var template = CompilerContext.compile('{{wycats bat=is.a baz=slave.driver}}', {trackIds: true});
+
+    var helpers = {
+      wycats: function(options) {
+        equal(options.hashIds.bat, 'is.a');
+        equal(options.hashIds.baz, 'slave.driver');
+
+        return "HELP ME MY BOSS " + options.hashIds.bat + ':' + options.hash.bat + ' ' + options.hashIds.baz + ':' + options.hash.baz;
+      }
+    };
+
+    equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS is.a:foo slave.driver:bar');
+  });
+  it('should note ../ and ./ references', function() {
+    var template = CompilerContext.compile('{{wycats ./is.a ../slave.driver}}', {trackIds: true});
+
+    var helpers = {
+      wycats: function(passiveVoice, noun, options) {
+        equal(options.ids[0], 'is.a');
+        equal(options.ids[1], '../slave.driver');
+
+        return "HELP ME MY BOSS " + options.ids[0] + ':' + passiveVoice + ' ' + options.ids[1] + ':' + noun;
+      }
+    };
+
+    equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS is.a:foo ../slave.driver:undefined');
+  });
+  it('should note @data references', function() {
+    var template = CompilerContext.compile('{{wycats @is.a @slave.driver}}', {trackIds: true});
+
+    var helpers = {
+      wycats: function(passiveVoice, noun, options) {
+        equal(options.ids[0], '@is.a');
+        equal(options.ids[1], '@slave.driver');
+
+        return "HELP ME MY BOSS " + options.ids[0] + ':' + passiveVoice + ' ' + options.ids[1] + ':' + noun;
+      }
+    };
+
+    equals(template({}, {helpers: helpers, data:context}), 'HELP ME MY BOSS @is.a:foo @slave.driver:bar');
+  });
+
+  it('should return null for constants', function() {
+    var template = CompilerContext.compile('{{wycats 1 "foo" key=false}}', {trackIds: true});
+
+    var helpers = {
+      wycats: function(passiveVoice, noun, options) {
+        equal(options.ids[0], null);
+        equal(options.ids[1], null);
+        equal(options.hashIds.key, null);
+
+        return "HELP ME MY BOSS " + passiveVoice + ' ' + noun + ' ' + options.hash.key;
+      }
+    };
+
+    equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS 1 foo false');
+  });
+  it('should return true for subexpressions', function() {
+    var template = CompilerContext.compile('{{wycats (sub)}}', {trackIds: true});
+
+    var helpers = {
+      sub: function() { return 1; },
+      wycats: function(passiveVoice, options) {
+        equal(options.ids[0], true);
+
+        return "HELP ME MY BOSS " + passiveVoice;
+      }
+    };
+
+    equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS 1');
+  });
+
+  describe('builtin helpers', function() {
+    var helpers = {
+      wycats: function(name, options) {
+        return name + ':' + options.data.contextPath + '\n';
+      }
+    };
+
+    describe('#each', function() {
+      it('should track contextPath for arrays', function() {
+        var template = CompilerContext.compile('{{#each array}}{{wycats name}}{{/each}}', {trackIds: true});
+
+        equals(template({array: [{name: 'foo'}, {name: 'bar'}]}, {helpers: helpers}), 'foo:array.0\nbar:array.1\n');
+      });
+      it('should track contextPath for keys', function() {
+        var template = CompilerContext.compile('{{#each object}}{{wycats name}}{{/each}}', {trackIds: true});
+
+        equals(template({object: {foo: {name: 'foo'}, bar: {name: 'bar'}}}, {helpers: helpers}), 'foo:object.foo\nbar:object.bar\n');
+      });
+      it('should handle nesting', function() {
+        var template = CompilerContext.compile('{{#each .}}{{#each .}}{{wycats name}}{{/each}}{{/each}}', {trackIds: true});
+
+        equals(template({array: [{name: 'foo'}, {name: 'bar'}]}, {helpers: helpers}), 'foo:.array..0\nbar:.array..1\n');
+      });
+    });
+    describe('#with', function() {
+      it('should track contextPath', function() {
+        var template = CompilerContext.compile('{{#with field}}{{wycats name}}{{/with}}', {trackIds: true});
+
+        equals(template({field: {name: 'foo'}}, {helpers: helpers}), 'foo:field\n');
+      });
+      it('should handle nesting', function() {
+        var template = CompilerContext.compile('{{#with bat}}{{#with field}}{{wycats name}}{{/with}}{{/with}}', {trackIds: true});
+
+        equals(template({bat: {field: {name: 'foo'}}}, {helpers: helpers}), 'foo:bat.field\n');
+      });
+    });
+    describe('#blockHelperMissing', function() {
+      it('should track contextPath for arrays', function() {
+        var template = CompilerContext.compile('{{#field}}{{wycats name}}{{/field}}', {trackIds: true});
+
+        equals(template({field: [{name: 'foo'}]}, {helpers: helpers}), 'foo:field.0\n');
+      });
+      it('should track contextPath for keys', function() {
+        var template = CompilerContext.compile('{{#field}}{{wycats name}}{{/field}}', {trackIds: true});
+
+        equals(template({field: {name: 'foo'}}, {helpers: helpers}), 'foo:field\n');
+      });
+      it('should handle nesting', function() {
+        var template = CompilerContext.compile('{{#bat}}{{#field}}{{wycats name}}{{/field}}{{/bat}}', {trackIds: true});
+
+        equals(template({bat: {field: {name: 'foo'}}}, {helpers: helpers}), 'foo:bat.field\n');
+      });
+    });
+  });
+});