diff --git a/.gitignore b/.gitignore
index e81f4c6..2dbf802 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 .idea/
 node_modules/
+dist/
+closure/
 TraceKit.iml
diff --git a/Gruntfile.js b/Gruntfile.js
index f623639..b9edabf 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -4,25 +4,31 @@ module.exports = function (grunt) {
 
     // Project configuration.
     grunt.initConfig({
-        'closureCompiler': {
+        clean: {
+            dist: ['dist']
+        },
+        closureCompiler: {
             options: {
                 compilerFile: './closure/compiler.jar',
                 checkModified: true,
                 compilerOpts: {
-                    compilation_level: 'ADVANCED_OPTIMIZATIONS',
+                    compilation_level: 'SIMPLE_OPTIMIZATIONS',
                     warning_level: 'verbose',
                     jscomp_off: ['checkTypes', 'fileoverviewTags'],
-                    summary_detail_level: 3,
-                    output_wrapper: '"(function(){%output%}).call(this);"'
+                    summary_detail_level: 3
                 },
                 execOpts: {
                     maxBuffer: 200 * 1024
                 }
 
             },
-            'compile': {
+            compile: {
                 src: './tracekit.js',
-                dest: './tracekit.min.js'
+                dest: './dist/tracekit.noplugins.min.js'
+            },
+            compileWithPlugins: {
+                src: ['./tracekit.js', './plugins/*.js'],
+                dest: './dist/tracekit.min.js'
             }
         },
         jshint: {
@@ -59,14 +65,28 @@ module.exports = function (grunt) {
                 ActiveXObject: false
             },
             lint: {
-                src: ['grunt.js', 'tracekit.js']
+                src: ['Gruntfile.js', 'tracekit.js', './plugins/*.js']
+            }
+        },
+        connect: {
+          test: {
+            options: {
+              port: 9001,
+              open: 'http://localhost:9001/tests/testBuild.html',
+              keepalive: true
             }
+          }
         }
     });
 
+    grunt.loadNpmTasks('grunt-contrib-clean');
+    grunt.loadNpmTasks('grunt-contrib-connect');
     grunt.loadNpmTasks('grunt-contrib-jshint');
     grunt.loadNpmTasks('grunt-closure-tools');
 
-    grunt.registerTask('default', ['jshint:lint', 'closureCompiler:compile']);
-    grunt.registerTask('travis', ['jshint:lint', 'closureCompiler:compile']);
+    grunt.registerTask('default', ['clean', 'jshint:lint', 'closureCompiler']);
+    grunt.registerTask('travis', ['clean', 'jshint:lint', 'closureCompiler']);
+
+    // Launch the recursion test
+    grunt.registerTask('test', ['default', 'connect:test']);
 };
diff --git a/README.md b/README.md
index 7d5aac0..70203e6 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ bower install tracekit
 ```
 This places TraceKit at `components/tracekit/tracekit.js`. Install [bower](http://twitter.github.com/bower/): `npm install bower -g`, download npm with Node: http://nodejs.org
 
-Then include the `<script>` to your page
+Then include the `<script>` in your page.
 
 ## Usage
 
@@ -74,6 +74,39 @@ TraceKit.collectWindowErrors = false;
 
 View the source for more details and examples.
 
+## Plugins
+
+Because most browsers support a [very limited window.onerror](https://bugzilla.mozilla.org/show_bug.cgi?id=355430) that
+does not pass an actual stack trace, TraceKit works around this with `TraceKit.wrap`. This is an easy mechanism for
+wrapping async functions. Previous versions of TraceKit wrapped jQuery event handlers and setTimeout/setInterval by default.
+That code is now in the plugins folder and can be used at will.
+
+In most applications, you'll want to include all plugins to ensure full stacktraces for as many errors as possible.
+
+Thankfully, in the newest version of the HTML5 Spec, and as of early September 2013, Chrome Canary [supports an
+extended window.onerror signature](https://code.google.com/p/chromium/issues/detail?id=147127) that passes an actual
+Error object along. In this case, TraceKit has the function `TraceKit.supportsExtendedWindowOnError`, which calls back 
+with a boolean. If true, `window.onerror` has superpowers and wrapping plugins should halt as their functionality
+is no longer needed.
+
+## Building
+
+To get minified versions of source, clone the project, and:
+
+```bash
+npm install
+wget http://closure-compiler.googlecode.com/files/compiler-latest.zip
+unzip compiler-latest.zip -d closure
+grunt
+```
+
+Built files will be stored in /dist.
+
+`tracekit.noplugins.min.js` does not wrap setTimeout/setInterval or jQuery. 
+
+`tracekit.min.js` contains setTimeout/setInterval & jQuery wrapping. If you need one but not the other,
+include the file in /plugins manually.
+
 ![Stacktrace or GTFO](http://i.imgur.com/jacoj.jpg)
 
 ## Contributing
diff --git a/package.json b/package.json
index 0fc2322..eb5525c 100644
--- a/package.json
+++ b/package.json
@@ -1,13 +1,15 @@
 {
-    "name": "TraceKit",
-    "version": "0.1.0",
-    "devDependencies": {
-        "grunt": "~0.4.1",
-        "grunt-contrib-jshint": "~0.6.2",
-        "grunt-cli": "~0.1.9",
-        "grunt-closure-tools": "~0.8.3"
-    },
-    "scripts": {
-        "test": "grunt --verbose travis"
-    }
-}
\ No newline at end of file
+  "name": "TraceKit",
+  "version": "0.1.0",
+  "devDependencies": {
+    "grunt": "~0.4.1",
+    "grunt-contrib-jshint": "~0.6.2",
+    "grunt-cli": "~0.1.9",
+    "grunt-closure-tools": "~0.8.3",
+    "grunt-contrib-clean": "~0.5.0",
+    "grunt-contrib-connect": "~0.5.0"
+  },
+  "scripts": {
+    "test": "grunt --verbose travis"
+  }
+}
diff --git a/plugins/wrapAsync.js b/plugins/wrapAsync.js
new file mode 100644
index 0000000..7f1ab3d
--- /dev/null
+++ b/plugins/wrapAsync.js
@@ -0,0 +1,34 @@
+/**
+ * Extends support for global error handling for asynchronous browser
+ * functions. Adopted from Closure Library's errorhandler.js
+ */
+(function extendToAsynchronousCallbacks(window) {
+
+    // Bail out if window.onerror can do this for us.
+    if (window.TraceKit.supportsExtendedWindowOnError()) {
+        return;
+    }
+
+    var _helper = function _helper(fnName) {
+        var originalFn = window[fnName];
+        window[fnName] = function traceKitAsyncExtension() {
+            // Make a copy of the arguments
+            var args = [].slice.call(arguments);
+            var originalCallback = args[0];
+            if (typeof (originalCallback) === 'function') {
+                args[0] = window.TraceKit.wrap(originalCallback);
+            }
+            // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
+            // also only supports 2 argument and doesn't care what "this" is, so we
+            // can just call the original function directly.
+            if (originalFn.apply) {
+                return originalFn.apply(this, args);
+            } else {
+                return originalFn(args[0], args[1]);
+            }
+        };
+    };
+
+    _helper('setTimeout');
+    _helper('setInterval');
+}(this));
\ No newline at end of file
diff --git a/plugins/wrapJquery.js b/plugins/wrapJquery.js
new file mode 100644
index 0000000..e1ba851
--- /dev/null
+++ b/plugins/wrapJquery.js
@@ -0,0 +1,82 @@
+/**
+ * Extended support for backtraces and global error handling for most
+ * asynchronous jQuery functions.
+ */
+(function traceKitAsyncForjQuery(window) {
+
+    // quit if jQuery or TraceKit isn't on the page
+    var $ = window.$;
+    var TraceKit = window.TraceKit;
+    if (!$ || !TraceKit) {
+        if (window.console && !TraceKit.suppressWarnings) {
+            window.console.warn('Unable to load TraceKit jQuery plugin: TraceKit or jQuery is not available ' +
+                'at the time of invocation.');
+        }
+        return;
+    }
+    // Bail out if window.onerror can do this work for us
+    if (window.TraceKit.supportsExtendedWindowOnError()) {
+        return;
+    }
+
+    var _oldEventAdd = $.event.add;
+    $.event.add = function traceKitEventAdd(elem, types, handler, data, selector) {
+        var _handler;
+
+        if (handler.handler) {
+            _handler = handler.handler;
+            handler.handler = TraceKit.wrap(handler.handler);
+        } else {
+            _handler = handler;
+            handler = TraceKit.wrap(handler);
+        }
+
+        // If the handler we are attaching doesn’t have the same guid as
+        // the original, it will never be removed when someone tries to
+        // unbind the original function later. Technically as a result of
+        // this our guids are no longer globally unique, but whatever, that
+        // never hurt anybody RIGHT?!
+        if (_handler.guid) {
+            handler.guid = _handler.guid;
+        } else {
+            handler.guid = _handler.guid = $.guid++;
+        }
+
+        return _oldEventAdd.call(this, elem, types, handler, data, selector);
+    };
+
+    var _oldReady = $.fn.ready;
+    $.fn.ready = function traceKitjQueryReadyWrapper(fn) {
+        return _oldReady.call(this, TraceKit.wrap(fn));
+    };
+
+    var _oldAjax = $.ajax;
+    $.ajax = function traceKitAjaxWrapper(url, options) {
+        var keys = ['complete', 'error', 'success'], key;
+
+        // Taken from https://github.com/jquery/jquery/blob/eee2eaf1d7a189d99106423a4206c224ebd5b848/src/ajax.js#L311-L318
+        // If url is an object, simulate pre-1.5 signature
+        if (typeof url === 'object') {
+            options = url;
+            url = undefined;
+        }
+
+        // Force options to be an object
+        options = options || {};
+
+        while(key = keys.pop()) {
+            if ($.isFunction(options[key])) {
+                options[key] = TraceKit.wrap(options[key]);
+            }
+        }
+
+        try {
+            return _oldAjax.call(this, url, options);
+        } catch (e) {
+            TraceKit.report(e);
+            throw e;
+        }
+    };
+
+
+}(this));
\ No newline at end of file
diff --git a/tests/newOnError.html b/tests/newOnError.html
new file mode 100644
index 0000000..eeda231
--- /dev/null
+++ b/tests/newOnError.html
@@ -0,0 +1,70 @@
+<!--
+A simple test for extended window.onerror support.
+See: https://mikewest.org/2013/08/debugging-runtime-errors-with-window-onerror 
+-->
+<!doctype html>
+<html>
+<head>
+  <title>TraceKit OnError Test</title>
+  <script src="../tracekit.js"></script>
+  <script>
+    setupTraceKit()
+    function setupTraceKit(){
+      function indent(text){
+        return text.split('\n').map(function(line){
+          return '  ' + line
+        }).join('\n')
+      }
+
+      TraceKit.report.subscribe(function(stackInfo){
+        var out = [];
+        out.push(stackInfo.name + ' : ' + stackInfo.message)
+        var stack = stackInfo.stack
+        if (!stack || stack.length === 0) return
+        if (stack[0].context){
+          out.push(indent(stack[0].context.join('\n')))
+        }
+        for (var i = 0; i < stack.length; i++){
+          var line = stack[i]
+          out.push('  at ' + line.func + ' (' + [line.url, line.line, line.column].join(':') + ')')
+        }
+
+        // Append to page
+        var output = document.getElementById('errorOutput');
+        var innerContentWrapper = document.createElement('pre');
+        var innerContent = document.createElement('li');
+        innerContent.innerHTML = escapeHtml(out.join('\n'));
+        innerContentWrapper.appendChild(innerContent);
+        output.appendChild(innerContentWrapper);
+      })
+    }
+    var entityMap = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': '&quot;',
+      "'": '&#39;',
+      "/": '&#x2F;'
+    };
+
+    function escapeHtml(string) {
+      return String(string).replace(/[&<>"'\/]/g, function (s) {
+        return entityMap[s];
+      });
+    }
+    // Throw a delayed error
+    setTimeout(function(){throw new Error('Delayed Error');}, 500);
+
+    // Throw an additional error if extended window.onerror is not supported.
+    TraceKit.supportsExtendedWindowOnError(function(supported) {
+      if (!supported) throw new Error("Extended window.onerror is not supported.");
+    });
+  </script>
+</head>
+<body>
+  <h1>TraceKit OnError Test</h1>
+  <h4>If your browser supports the new onError signature, you should see column numbers on traces
+      and headers starting with 'Error', not 'undefined'.</h4>
+  <div id="errorOutput"></div>
+</body>
+</html>
\ No newline at end of file
diff --git a/tests/recursion.html b/tests/recursion.html
index 4a6762b..5c49e72 100644
--- a/tests/recursion.html
+++ b/tests/recursion.html
@@ -51,7 +51,7 @@
 <script>
 describe('crash', function(){
 
-    it('it should not go into an infinite loop', function(){
+    it('it should not go into an infinite loop - if you see output here, it worked correctly.', function(){
         throw new Error('Boom!');
     });
     
diff --git a/tests/testBuild.html b/tests/testBuild.html
new file mode 100644
index 0000000..4152b8f
--- /dev/null
+++ b/tests/testBuild.html
@@ -0,0 +1,69 @@
+<!--
+If you run this file under IE9, it will make the browser become unresponsive because TraceKit will be stuck in an infinite loop in the function `computeStackTraceByWalkingCallerChain` prior to the fix.
+
+-->
+<!doctype html>
+<html>
+<head>
+<title>TraceKit Build Test</title>
+<script src="../dist/tracekit.noplugins.min.js"></script>
+<link href="mocha.css" rel="stylesheet">
+<script src="mocha.js"></script>
+<script>
+
+setupTraceKit()
+function setupTraceKit(){
+    function indent(text){
+        return text.split('\n').map(function(line){
+            return '    ' + line
+        }).join('\n')
+    }
+
+    TraceKit.report.subscribe(function(stackInfo){
+        console.log(stackInfo.name + ' : ' + stackInfo.message)
+        var stack = stackInfo.stack
+        if (!stack || stack.length === 0) return
+        if (stack[0].context){
+            console.log(indent(stack[0].context.join('\n')))
+        }
+        for (var i = 0; i < stack.length; i++){
+            var line = stack[i]
+
+            console.log('    at ' + line.func + ' (' + [line.url, line.line, line.column].join(':') + ')')
+        }
+    })
+}
+
+interceptMochaRunner()
+function interceptMochaRunner(){
+    var Runner = mocha.Runner || Mocha.Runner
+    var oEmit = Runner.prototype.emit
+    Runner.prototype.emit = function(evt, test){
+        if (evt === 'test end'){
+            if (test.err) TraceKit.report(test.err)
+        }
+        oEmit.apply(this, arguments)
+    }
+}
+
+</script>
+<script>mocha.setup('bdd')</script>
+<script>
+describe('crash', function(){
+
+    it('it should not go into an infinite loop - if you see output here, it worked correctly.', function(){
+        throw new Error('Boom!');
+    });
+    
+});
+</script>
+</head>
+<body>
+<h1>TraceKit Build Test</h1>
+<p>You should see output below and no errors (just logging) in the console. If not, the build has broken.</p>
+<div id="mocha"></div>
+<script>
+mocha.run()
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/tracekit.js b/tracekit.js
index cea78b3..1565763 100644
--- a/tracekit.js
+++ b/tracekit.js
@@ -57,6 +57,40 @@ TraceKit.wrap = function traceKitWrapper(func) {
     return wrapped;
 };
 
+/**
+ * TraceKit.supportsExtendedWindowOnError: Returns a boolean indicating
+ * support for the extended window.onerror handler, part of the HTML5 spec as of 
+ * August 2013. (https://mikewest.org/2013/08/debugging-runtime-errors-with-window-onerror)
+ *
+ * Call this function from a plugin to determine if you should wrap a function or not.
+ * If the browser supports extended window.onerror, there is no need to wrap jQuery,
+ * setTimeout, etc. as they will receive decent stacks from window.onerror itself.
+ *
+ * An easy way to test for support is to check for an error & colno attribute
+ * on a created ErrorEvent. See 
+ * https://src.chromium.org/viewvc/blink/trunk/LayoutTests/fast/events/constructors/error-event-constructor.html?r1=155454&r2=155453&pathrev=155454
+ * 
+ * @returns {Boolean} supportedExtendedOnError Support enabled/disabled boolean.
+ */
+TraceKit.supportsExtendedWindowOnError = function supportsExtendedWindowOnError() {
+    if (!window.ErrorEvent){
+        return false;
+    }
+    
+    var testError;
+    try {
+        testError = new window.ErrorEvent('eventType', {error: {foo: 12345}});
+    } catch(e){
+        // IE breaks with "Object doesn't support this action"
+        return false;
+    }
+
+    if (testError.error && testError.error.foo === 12345 && typeof testError.colno === 'number'){
+        return true;
+    }
+    return false;
+};
+
 /**
  * TraceKit.report: cross-browser processing of unhandled exceptions
  *
@@ -156,7 +190,7 @@ TraceKit.report = (function reportModuleWrapper() {
      * @param {(number|string)} lineNo The line number at which the error
      * occurred.
      */
-    function traceKitWindowOnError(message, url, lineNo) {
+    function traceKitWindowOnError(message, url, lineNo, colNo, error) {
         var stack = null;
 
         if (lastExceptionStack) {
@@ -164,6 +198,9 @@ TraceKit.report = (function reportModuleWrapper() {
             stack = lastExceptionStack;
             lastExceptionStack = null;
             lastException = null;
+        } else if (error) {
+            // New HTML5 spec (Aug 2013) actually passes an error to window.onerror
+            stack = TraceKit.computeStackTrace(error);
         } else {
             var location = {
                 'url': url,
@@ -1063,35 +1100,6 @@ TraceKit.computeStackTrace = (function computeStackTraceWrapper() {
     return computeStackTrace;
 }());
 
-/**
- * Extends support for global error handling for asynchronous browser
- * functions. Adopted from Closure Library's errorhandler.js
- */
-(function extendToAsynchronousCallbacks() {
-    var _helper = function _helper(fnName) {
-        var originalFn = window[fnName];
-        window[fnName] = function traceKitAsyncExtension() {
-            // Make a copy of the arguments
-            var args = _slice.call(arguments);
-            var originalCallback = args[0];
-            if (typeof (originalCallback) === 'function') {
-                args[0] = TraceKit.wrap(originalCallback);
-            }
-            // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
-            // also only supports 2 argument and doesn't care what "this" is, so we
-            // can just call the original function directly.
-            if (originalFn.apply) {
-                return originalFn.apply(this, args);
-            } else {
-                return originalFn(args[0], args[1]);
-            }
-        };
-    };
-
-    _helper('setTimeout');
-    _helper('setInterval');
-}());
-
 //Default options:
 if (!TraceKit.remoteFetching) {
   TraceKit.remoteFetching = true;
@@ -1103,6 +1111,10 @@ if (!TraceKit.linesOfContext || TraceKit.linesOfContext < 1) {
   // 5 lines before, the offending line, 5 lines after
   TraceKit.linesOfContext = 11;
 }
+// Set to true to ignore e.g. plugin warnings
+if (typeof TraceKit.suppressWarnings === 'undefined') {
+  TraceKit.suppressWarnings = false;
+}