diff --git a/karma-js.conf.js b/karma-js.conf.js
index 373b659459..1e97d2219e 100644
--- a/karma-js.conf.js
+++ b/karma-js.conf.js
@@ -30,7 +30,6 @@ module.exports = function(config) {
 
     exclude: [
       'dist/js/dev/es5/**/e2e_test/**',
-      'dist/js/dev/es5/rtts_assert/**',
       'dist/angular1_router.js'
     ],
 
diff --git a/modules/angular2/package.json b/modules/angular2/package.json
index fa1a6b8ba9..cc3f79194b 100644
--- a/modules/angular2/package.json
+++ b/modules/angular2/package.json
@@ -10,7 +10,6 @@
   "dependencies": {
     "traceur": "<%= packageJson.dependencies.traceur %>",
     "reflect-metadata": "<%= packageJson.dependencies['reflect-metadata'] %>",
-    "rtts_assert": "<%= packageJson.version %>",
     "rx": "<%= packageJson.dependencies['rx'] %>",
     "zone.js": "<%= packageJson.dependencies['zone.js'] %>"
   },
diff --git a/modules/angular2/src/test_lib/test_lib.ts b/modules/angular2/src/test_lib/test_lib.ts
index 0dcaaa6398..8fda3f8a5a 100644
--- a/modules/angular2/src/test_lib/test_lib.ts
+++ b/modules/angular2/src/test_lib/test_lib.ts
@@ -392,14 +392,12 @@ export class SpyObject {
     return object;
   }
 
-  rttsAssert(value) { return true; }
-
   _createGuinnessCompatibleSpy(name): GuinessCompatibleSpy {
     var newSpy: GuinessCompatibleSpy = <any>jasmine.createSpy(name);
     newSpy.andCallFake = <any>newSpy.and.callFake;
     newSpy.andReturn = <any>newSpy.and.returnValue;
     newSpy.reset = <any>newSpy.calls.reset;
-    // return null by default to satisfy our rtts asserts
+    // revisit return null here (previously needed for rtts_assert).
     newSpy.and.returnValue(null);
     return newSpy;
   }
diff --git a/modules/angular2/test/test_lib/test_lib_spec.ts b/modules/angular2/test/test_lib/test_lib_spec.ts
index 34cc99bb4b..ce03bea17e 100644
--- a/modules/angular2/test/test_lib/test_lib_spec.ts
+++ b/modules/angular2/test/test_lib/test_lib_spec.ts
@@ -125,8 +125,7 @@ export function main() {
          () => { expect(() => spyObj.someFunc()).not.toThrow(); });
 
       it('should create a default spy that does not fail for numbers', () => {
-        // Need to return null instead of undefined so that rtts assert does
-        // not fail...
+        // Previously needed for rtts_assert. Revisit this behavior.
         expect(spyObj.someFunc()).toBe(null);
       });
     });
diff --git a/modules/angular2_material/package.json b/modules/angular2_material/package.json
index a64ceb103f..ae9286d760 100644
--- a/modules/angular2_material/package.json
+++ b/modules/angular2_material/package.json
@@ -10,7 +10,6 @@
   "dependencies": {
     "angular2": "<%= packageJson.version %>",
     "traceur": "<%= packageJson.dependencies.traceur %>",
-    "rtts_assert": "<%= packageJson.version %>",
     "rx": "<%= packageJson.dependencies['rx'] %>",
     "zone.js": "<%= packageJson.dependencies['zone.js'] %>"
   },
diff --git a/modules/benchpress/src/webdriver/selenium_webdriver_adapter.ts b/modules/benchpress/src/webdriver/selenium_webdriver_adapter.ts
index bf4a639804..30c9268f99 100644
--- a/modules/benchpress/src/webdriver/selenium_webdriver_adapter.ts
+++ b/modules/benchpress/src/webdriver/selenium_webdriver_adapter.ts
@@ -17,7 +17,7 @@ export class SeleniumWebDriverAdapter extends WebDriverAdapter {
     thenable.then(
         // selenium-webdriver uses an own Node.js context,
         // so we need to convert data into objects of this context.
-        // (e.g. otherwise instanceof checks of rtts_assert would fail)
+        // Previously needed for rtts_asserts.
         (data) => completer.resolve(convertToLocalProcess(data)), completer.reject);
     return completer.promise;
   }
diff --git a/modules/rtts_assert/README.js.md b/modules/rtts_assert/README.js.md
deleted file mode 100644
index 1ead525a67..0000000000
--- a/modules/rtts_assert/README.js.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Rtts-Assert
-
-A run-time type assertion library for JavaScript.
-Designed to be used with [Traceur](https://github.com/google/traceur-compiler).
-
-All sources are in ES6 format. They don't depend on any runtime
-and can be used by any modern ES6 -> ES5 transpiler.
-
-As a convenience, we provide you with `es5build.js`, a script to transpile the sources into es5
-using [Google Traceur](https://github.com/google/traceur-compiler/).
-
-License: Apache MIT 2.0
-
-## API
-
-```
-// Asserting APIs:
-// - generated by Traceur (based on type annotations)
-// - can be also used in tests for instance
-assert.type(something, Type);
-assert.returnType(returnValue, Type);
-assert.argumentTypes(firstArg, Type, secondArg, Type);
-
-// this can be used anywhere in the code
-// (useful inside test, when we don't wanna define an interface)
-assert(value).is(...)
-
-
-// Custom type assert:
-// - i have a custom type
-// - adding an assert methods
-assert.define(MyUser, function(value) {
-  assert(value).is(Type, Type2); // or
-  assert(value, 'name').is(assert.string);
-  assert(value, 'contact').is(assert.structure({
-    email: assert.string,
-    cell: assert.string
-  }));
-  assert(value, 'contacts').is(assert.arrayOf(assert.structure({email: assert.string})));
-});
-
-
-// Define interface (an empty type with assert method)
-// - returns an empty class with assert method
-var Email = assert.define('IEmail', function(value) {
-  assert(value).is(String);
-
-  if (value.indexOf('@') !== -1) {
-    assert.fail('has to contain "@"');
-  }
-});
-
-
-// Predefined types
-assert.string
-assert.number
-assert.boolean
-assert.arrayOf(...types)
-assert.structure(object)
-```
\ No newline at end of file
diff --git a/modules/rtts_assert/package.json b/modules/rtts_assert/package.json
deleted file mode 100644
index 4a448cd809..0000000000
--- a/modules/rtts_assert/package.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "name": "rtts_assert",
-  "version": "<%= packageJson.version %>",
-  "description": "A run-time type assertion library for JavaScript",
-  "homepage": "<%= packageJson.homepage %>",
-  "bugs": "<%= packageJson.bugs %>",
-  "contributors": <%= JSON.stringify(packageJson.contributors) %>,
-  "license": "<%= packageJson.license %>",
-  "repository": <%= JSON.stringify(packageJson.repository) %>,
-  "devDependencies": {
-    "yargs": "2.3.*",
-    "gulp-sourcemaps": "1.3.*",
-    "gulp-traceur": "0.16.*",
-    "gulp": "^3.8.8",
-    "gulp-rename": "^1.2.0",
-    "through2": "^0.6.1"
-  }
-}
diff --git a/modules/rtts_assert/rtts_assert.ts b/modules/rtts_assert/rtts_assert.ts
deleted file mode 100644
index dce716a413..0000000000
--- a/modules/rtts_assert/rtts_assert.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from './src/rtts_assert';
diff --git a/modules/rtts_assert/src/rtts_assert.ts b/modules/rtts_assert/src/rtts_assert.ts
deleted file mode 100644
index e96e0b147e..0000000000
--- a/modules/rtts_assert/src/rtts_assert.ts
+++ /dev/null
@@ -1,369 +0,0 @@
-var _global = typeof window === 'object' ? window : global;
-
-// TODO(vojta):
-// - extract into multiple files
-// - different error types
-// - simplify/humanize error messages
-// - throw when invalid input (such as odd number of args into assert.argumentTypes)
-
-var POSITION_NAME = ['', '1st', '2nd', '3rd'];
-function argPositionName(i) {
-  var position = (i / 2) + 1;
-
-  return POSITION_NAME[position] || (position + 'th');
-}
-
-var primitives;
-var genericType;
-
-if (typeof _global['$traceurRuntime'] === 'object') {
-  primitives = _global['$traceurRuntime'].type;
-  genericType = _global['$traceurRuntime'].genericType;
-} else {
-  // Allow to work without traceur runtime as well!
-  primitives = {
-    any: {name: 'any'},
-    boolean: {name: 'boolean'},
-    number: {name: 'number'},
-    string: {name: 'string'},
-    symbol: {name: 'symbol'}, void: {name: 'void'}
-  };
-  genericType = function(type, args) {
-    return { type: type, args: args }
-  }
-}
-Object.keys(primitives).forEach(function(name) { primitives[name].__assertName = name; });
-
-export function proxy() {}
-
-function assertArgumentTypes(...params) {
-  var actual, type;
-  var currentArgErrors;
-  var errors = [];
-  var msg;
-
-  for (var i = 0, l = params.length; i < l; i = i + 2) {
-    actual = params[i];
-    type = params[i + 1];
-
-    currentArgErrors = [];
-
-    // currentStack = [];
-    //
-
-    if (!isType(actual, type, currentArgErrors)) {
-      // console.log(JSON.stringify(errors, null, '  '));
-      // TODO(vojta): print "an instance of" only if T starts with uppercase.
-      errors.push(argPositionName(i) + ' argument has to be an instance of ' + prettyPrint(type) +
-                  ', got ' + prettyPrint(actual));
-      if (currentArgErrors.length) {
-        errors.push(currentArgErrors);
-      }
-    }
-  }
-
-  if (errors.length) {
-    throw new Error('Invalid arguments given!\n' + formatErrors(errors));
-  }
-}
-
-function prettyPrint(value, depth?) {
-  if (typeof(depth) === 'undefined') {
-    depth = 0;
-  }
-
-  if (depth++ > 3) {
-    return '[...]';
-  }
-
-  if (typeof value === 'undefined') {
-    return 'undefined';
-  }
-
-  if (typeof value === 'string') {
-    return '"' + value + '"';
-  }
-
-  if (typeof value === 'boolean') {
-    return value.toString();
-  }
-
-  if (value === null) {
-    return 'null';
-  }
-
-  if (typeof value === 'object') {
-    if (value.__assertName) {
-      return value.__assertName;
-    }
-
-    if (value.map && typeof value.map === 'function') {
-      return '[' + value.map((v) => prettyPrint(v, depth)).join(', ') + ']';
-    }
-
-    var properties = Object.keys(value);
-    var suffix = '}';
-    if (properties.length > 20) {
-      properties.length = 20;
-      suffix = ', ... }';
-    }
-    return '{' + properties.map((p) => p + ': ' + prettyPrint(value[p], depth)).join(', ') + suffix;
-  }
-
-  return value.__assertName || value.name || value.toString();
-}
-
-function isType(value, T, errors) {
-  if (T && T.type) {
-    // needed for generics.
-    // TODO(tbosch): read out T.args and do assertions based on them as well!
-    T = T.type;
-  }
-  if (T === primitives.void) {
-    return typeof value === 'undefined';
-  }
-
-  if (_isProxy(value)) {
-    return true;
-  }
-
-  if (T === primitives.any || value === null) {
-    return true;
-  }
-
-  if (T === primitives.string) {
-    return typeof value === 'string';
-  }
-
-  if (T === primitives.number) {
-    return typeof value === 'number';
-  }
-
-  if (T === primitives.boolean) {
-    return typeof value === 'boolean';
-  }
-
-  // var parentStack = currentStack;
-  // currentStack = [];
-
-  // shouldnt this create new stack?
-  if (typeof T.assert === 'function') {
-    var parentStack = currentStack;
-    var isValid;
-    currentStack = errors;
-    try {
-      isValid = T.assert(value);
-    } catch (e) {
-      fail(e.message);
-      isValid = false;
-    }
-
-    currentStack = parentStack;
-
-    if (typeof isValid === 'undefined') {
-      isValid = errors.length === 0;
-    }
-
-    return isValid;
-
-    // if (!currentStack.length) {
-    //   currentStack = parentStack;
-    //   return [];
-    // }
-    // var res = currentStack;
-    // currentStack = parentStack;
-    // return ['not instance of ' + prettyPrint(T), res];
-  }
-
-  return value instanceof T;
-
-  // if (!(value instanceof T)) {
-  //   fail('not instance of ' + prettyPrint(T));
-  // }
-
-  // var res = currentStack;
-  // currentStack = parentStack;
-
-  // return res;
-}
-
-function _isProxy(obj) {
-  if (!obj || !obj.constructor || !obj.constructor.annotations) return false;
-  return obj.constructor.annotations.filter((a) => a instanceof proxy).length > 0;
-}
-
-function formatErrors(errors, indent = '  ') {
-  return errors.map((e) => {
-                 if (typeof e === 'string') return indent + '- ' + e;
-                 return formatErrors(e, indent + '  ');
-               })
-      .join('\n');
-}
-
-
-// assert a type of given value and throw if does not pass
-var type: any =
-    function(actual, T) {
-  var errors = [];
-  // currentStack = [];
-
-  if (!isType(actual, T, errors)) {
-    // console.log(JSON.stringify(errors, null, '  '));
-    // TODO(vojta): print "an instance of" only if T starts with uppercase.
-    var msg = 'Expected an instance of ' + prettyPrint(T) + ', got ' + prettyPrint(actual) + '!';
-    if (errors.length) {
-      msg += '\n' + formatErrors(errors);
-    }
-
-    throw new Error(msg);
-  }
-  return actual;
-}
-
-function returnType(actual, T) {
-  var errors = [];
-  // currentStack = [];
-
-  if (!isType(actual, T, errors)) {
-    // console.log(JSON.stringify(errors, null, '  '));
-    // TODO(vojta): print "an instance of" only if T starts with uppercase.
-    var msg = 'Expected to return an instance of ' + prettyPrint(T) + ', got ' +
-              prettyPrint(actual) + '!';
-    if (errors.length) {
-      msg += '\n' + formatErrors(errors);
-    }
-
-    throw new Error(msg);
-  }
-
-  return actual;
-}
-
-// TODO(vojta): define these with DSL?
-var string = type.string = define('string', function(value) { return typeof value === 'string'; });
-
-var boolean = type.boolean =
-    define('boolean', function(value) { return typeof value === 'boolean'; });
-
-var number = type.number = define('number', function(value) { return typeof value === 'number'; });
-
-function arrayOf(...types) {
-  return assert.define('array of ' + types.map(prettyPrint).join('/'), function(value) {
-    if (assert(value).is(Array)) {
-      for (var i = 0; i < value.length; i++) {
-        assert(value[i]).is(...types);
-      }
-    }
-  });
-}
-
-function structure(definition) {
-  var properties = Object.keys(definition);
-  return assert.define('object with properties ' + properties.join(', '), function(value) {
-    if (assert(value).is(Object)) {
-      for (var i = 0; i < properties.length; i++) {
-        var property = properties[i];
-        assert(value[property]).is(definition[property]);
-      }
-    }
-  })
-}
-
-
-
-// I'm sorry, bad global state... to make the API nice ;-)
-var currentStack = [];
-
-function fail(message) {
-  currentStack.push(message);
-}
-
-function define(classOrName, check) {
-  var cls = classOrName;
-
-  if (typeof classOrName === 'string') {
-    cls = function() {};
-    cls.__assertName = classOrName;
-  }
-
-  cls.assert = function(value) {
-    // var parentStack = currentStack;
-
-    // currentStack = [];
-
-    return check(value);
-
-    // if (currentStack.length) {
-    //   parentStack.push(currentStack)
-    // }
-    // currentStack = parentStack;
-  };
-
-  return cls;
-}
-
-
-var assert: any = function(value) {
-  return {
-    is: function is(...types) {
-      // var errors = []
-      var allErrors = [];
-      var errors;
-      for (var i = 0; i < types.length; i++) {
-        var type = types[i];
-        errors = [];
-
-        if (isType(value, type, errors)) {
-          return true;
-        }
-
-        // if no errors, merge multiple "is not instance of " into x/y/z ?
-        allErrors.push(prettyPrint(value) + ' is not instance of ' + prettyPrint(type));
-        if (errors.length) {
-          allErrors.push(errors);
-        }
-      }
-
-      // if (types.length > 1) {
-      //   currentStack.push(['has to be ' + types.map(prettyPrint).join(' or '),
-      //   ...allErrors]);
-      // } else {
-      currentStack.push(...allErrors);
-      // }
-      return false;
-    }
-  };
-};
-
-
-// PUBLIC API
-
-// asserting API
-
-// throw if no type provided
-assert.type = type;
-for (var prop in primitives) {
-  assert.type[prop] = primitives[prop];
-}
-assert.genericType = genericType;
-
-// throw if odd number of args
-assert.argumentTypes = assertArgumentTypes;
-assert.returnType = returnType;
-
-
-// define AP;
-assert.define = define;
-assert.fail = fail;
-
-// primitive value type;
-assert.string = string;
-assert.number = number;
-assert.boolean = boolean;
-
-// custom types
-assert.arrayOf = arrayOf;
-assert.structure = structure;
-
-
-export {assert}
diff --git a/modules/rtts_assert/test/rtts_assert_spec.ts b/modules/rtts_assert/test/rtts_assert_spec.ts
deleted file mode 100644
index 4a73e9edc1..0000000000
--- a/modules/rtts_assert/test/rtts_assert_spec.ts
+++ /dev/null
@@ -1,367 +0,0 @@
-// # Assert.js
-// A run-time type assertion library for JavaScript. Designed to be used with
-// [Traceur](https://github.com/google/traceur-compiler).
-import {assert} from '../rtts_assert';
-
-// - [Basic Type Check](#basic-type-check)
-// - [Custom Check](#custom-check)
-// - [Primitive Values](#primitive-values)
-// - [Describing more complex types](#describing-more-complex-types)
-//   - [assert.arrayOf](#assert-arrayof)
-//   - [assert.structure](#assert-structure)
-// - [Integrating with Traceur](#integrating-with-traceur)
-
-// Note: `assert` gets automatically included by traceur!
-
-export function main() {
-  return;
-
-  describe('prettyPrint', () => {
-    function Type() {}
-
-    it('should limit the number of printed properties', () => {
-      var o = {};
-      for (var i = 0; i < 100; i++) {
-        o['p_' + i] = i;
-      }
-      try {
-        assert.type(o, Type);
-        throw 'fail!';
-      } catch (e) {
-        expect(e.message.indexOf('p_0')).toBeGreaterThan(-1);
-        expect(e.message.indexOf('...')).toBeGreaterThan(-1);
-        expect(e.message.indexOf('p_20')).toEqual(-1);
-      }
-    });
-
-    it('should limit the depth of printed properties', () => {
-      var o = {l1: {l2: {l3: {l4: {l5: {l6: 'deep'}}}}}};
-
-      expect(() => { assert.type(o, Type); })
-          .toThrowError('Expected an instance of Type, got {l1: {l2: {l3: {l4: [...]}}}}!');
-    });
-  });
-
-  // ## Basic Type Check
-  // By default, `instanceof` is used to check the type.
-  //
-  // Note that you can use `assert.type()` in unit tests or anywhere in your code.
-  // Most of the time, you will use it with Traceur.
-  // Jump to the [Traceur section](#integrating-with-traceur) to see an example of that.
-  describe('basic type check', function() {
-
-    function Type() {}
-
-    it('should pass', function() { assert.type(new Type(), Type); });
-
-
-    it('should fail', function() {
-      expect(() => assert.type(123, Type)).toThrowError('Expected an instance of Type, got 123!');
-    });
-
-
-    it('should allow null', function() { assert.type(null, Type); });
-  });
-
-
-
-  // ## Custom Check
-  // Often, `instanceof` is not flexible enough.
-  // In that case, your type can define its own `assert` method which will be used instead.
-  //
-  // See [Describing More Complex Types](#describing-more-complex-types) for examples how to
-  // define custom checks using `assert.define()`.
-  describe('custom check', function() {
-
-    function Type() {}
-
-    // the basic check can just return true/false, without specifying any reason
-    it('should pass when returns true', function() {
-      (<any>Type).assert = function(value) { return true; };
-
-      assert.type({}, Type);
-    });
-
-
-    it('should fail when returns false', function() {
-      (<any>Type).assert = function(value) { return false; };
-
-      expect(() => assert.type({}, Type)).toThrowError('Expected an instance of Type, got {}!');
-    });
-
-
-    // Using `assert.fail()` allows to report even multiple errors.
-    it('should fail when calls assert.fail()', function() {
-      (<any>Type).assert = function(value) {
-        assert.fail('not smart enough');
-        assert.fail('not blue enough');
-      };
-
-      expect(() => assert.type({}, Type))
-          .toThrowError('Expected an instance of Type, got {}!\n' +
-                        '  - not smart enough\n' +
-                        '  - not blue enough');
-    });
-
-
-    it('should fail when throws an exception', function() {
-      (<any>Type).assert = function(value) { throw new Error('not long enough'); };
-
-      expect(function() { assert.type(12345, Type); })
-          .toThrowError('Expected an instance of Type, got 12345!\n' +
-                        '  - not long enough');
-    });
-  });
-
-
-
-  // ## Primitive Values
-  // You don't want to check primitive values (such as strings, numbers, or booleans) using `typeof`
-  // rather than
-  // `instanceof`.
-  //
-  // Again, you probably won't write this code and rather use Traceur to do it for you, simply based
-  // on type annotations.
-  describe('primitive value check', function() {
-    var primitive = global['$traceurRuntime'].type;
-
-    describe('string', function() {
-
-      it('should pass', function() { assert.type('xxx', primitive.string); });
-
-
-      it('should fail', function() {
-        expect(() => assert.type(12345, primitive.string))
-            .toThrowError('Expected an instance of string, got 12345!');
-      });
-
-      it('should allow null', function() { assert.type(null, primitive.string); });
-    });
-
-
-    describe('number', function() {
-
-      it('should pass', function() { assert.type(123, primitive.number); });
-
-
-      it('should fail', function() {
-        expect(() => assert.type(false, primitive.number))
-            .toThrowError('Expected an instance of number, got false!');
-      });
-
-      it('should allow null', function() { assert.type(null, primitive.number); });
-    });
-
-
-    describe('boolean', function() {
-
-      it('should pass', function() {
-        expect(assert.type(true, primitive.boolean)).toEqual(true);
-        expect(assert.type(false, primitive.boolean)).toEqual(false);
-      });
-
-
-      it('should fail', function() {
-        expect(() => assert.type(123, primitive.boolean))
-            .toThrowError('Expected an instance of boolean, got 123!');
-      });
-
-      it('should allow null', function() { assert.type(null, primitive.boolean); });
-    });
-  });
-
-
-  // ## Describing more complex types
-  //
-  // Often, a simple type check using `instanceof` or `typeof` is not enough.
-  // That's why you can define custom checks using this DSL.
-  // The goal was to make them easy to compose and as descriptive as possible.
-  // Of course you can write your own DSL on the top of this.
-  describe('define', function() {
-
-    // If the first argument to `assert.define()` is a type (function), it will define `assert`
-    // method on that function.
-    //
-    // In this example, being a type of Type means being a either a function or object.
-    it('should define assert for an existing type', function() {
-      function Type() {}
-
-      assert.define(Type, function(value) { assert(value).is(Function, Object); });
-
-      assert.type({}, Type);
-      assert.type(function() {}, Type);
-      expect(() => assert.type('str', Type))
-          .toThrowError('Expected an instance of Type, got "str"!\n' +
-                        '  - "str" is not instance of Function\n' +
-                        '  - "str" is not instance of Object');
-    });
-
-
-    // If the first argument to `assert.define()` is a string,
-    // it will create an interface - basically an empty class with `assert` method.
-    it('should define an interface', function() {
-      var User = assert.define('MyUser', function(user) { assert(user).is(Object); });
-
-      assert.type({}, User);
-      expect(() => assert.type(12345, User))
-          .toThrowError('Expected an instance of MyUser, got 12345!\n' +
-                        '  - 12345 is not instance of Object');
-    });
-
-
-    // Here are a couple of more APIs to describe your custom types...
-    //
-    // ### assert.arrayOf
-    // Checks if the value is an array and if so, it checks whether all the items are one the given
-    // types.
-    // These types can be composed types, not just simple ones.
-    describe('arrayOf', function() {
-
-      var Titles = assert.define('ListOfTitles', function(value) {
-        assert(value).is(assert.arrayOf(assert.string, assert.number));
-      });
-
-      it('should pass', function() { assert.type(['one', 55, 'two'], Titles); });
-
-
-      it('should fail when non-array given', function() {
-        expect(() => assert.type('foo', Titles))
-            .toThrowError('Expected an instance of ListOfTitles, got "foo"!\n' +
-                          '  - "foo" is not instance of array of string/number\n' +
-                          '    - "foo" is not instance of Array');
-      });
-
-
-      it('should fail when an invalid item in the array', function() {
-        expect(() => assert.type(['aaa', true], Titles))
-            .toThrowError('Expected an instance of ListOfTitles, got ["aaa", true]!\n' +
-                          '  - ["aaa", true] is not instance of array of string/number\n' +
-                          '    - true is not instance of string\n' +
-                          '    - true is not instance of number');
-      });
-    });
-
-
-    // ### assert.structure
-    // Similar to `assert.arrayOf` which checks a content of an array,
-    // `assert.structure` checks if the value is an object with specific properties.
-    describe('structure', function() {
-
-      var User = assert.define('MyUser', function(value) {
-        assert(value).is(assert.structure({name: assert.string, age: assert.number}));
-      });
-
-      it('should pass', function() { assert.type({name: 'Vojta', age: 28}, User); });
-
-
-      it('should fail when non-object given', function() {
-        expect(() => assert.type(123, User))
-            .toThrowError('Expected an instance of MyUser, got 123!\n' +
-                          '  - 123 is not instance of object with properties name, age\n' +
-                          '    - 123 is not instance of Object');
-      });
-
-
-      it('should fail when an invalid property', function() {
-        expect(() => assert.type({name: 'Vojta', age: true}, User))
-            .toThrowError(
-                'Expected an instance of MyUser, got {name: "Vojta", age: true}!\n' +
-                '  - {name: "Vojta", age: true} is not instance of object with properties name, age\n' +
-                '    - true is not instance of number');
-      });
-    });
-  });
-
-
-
-  // ## Integrating with Traceur
-  //
-  // Manually calling `assert.type()` in your code is cumbersome. Most of the time, you'll want to
-  // have Traceur add the calls to `assert.type()` to your code based on type annotations.
-  //
-  // This has several advantages:
-  // - it's shorter and nicer,
-  // - you can easily ignore it when generating production code.
-  //
-  // You'll need to run Traceur with `--types=true --type-assertions=true
-  // --type-assertion-module="path/to/assert"`.
-  describe('Traceur', function() {
-
-    describe('arguments', function() {
-
-      function reverse(str: string) { return str ? reverse(str.substring(1)) + str[0] : '' }
-
-      it('should pass', function() { expect(reverse('angular')).toEqual('ralugna'); });
-
-
-      it('should fail', function() {
-        expect(() => reverse(<any>123))
-            .toThrowError('Invalid arguments given!\n' +
-                          '  - 1st argument has to be an instance of string, got 123');
-      });
-    });
-
-
-    describe('return value', function() {
-
-      function foo(bar): number { return bar; }
-
-      it('should pass', function() { expect(foo(123)).toEqual(123); });
-
-
-      it('should fail', function() {
-        expect(() => foo('bar'))
-            .toThrowError('Expected to return an instance of number, got "bar"!');
-      });
-    });
-
-
-    describe('variables', function() {
-
-      it('should pass', function() { var count: number = 1; });
-
-
-      it('should fail', function() {
-        expect(() => { var count: number = <any>true; })
-            .toThrowError('Expected an instance of number, got true!');
-      });
-    });
-
-
-    describe('void', function() {
-      function foo(bar?): void { return bar; }
-
-      it('should pass when not defined', function() {
-        function nonReturn(): void {}
-        function returnNothing(): void { return; }
-        function returnUndefined(): void { return undefined; }
-
-        foo();
-        foo(undefined);
-        nonReturn();
-        returnNothing();
-        returnUndefined();
-      });
-
-
-      it('should fail when a value returned', function() {
-        expect(() => foo('bar')).toThrowError('Expected to return an instance of void, got "bar"!');
-      });
-
-
-      it('should fail when null returned', function() {
-        expect(() => foo(null)).toThrowError('Expected to return an instance of void, got null!');
-      });
-    });
-
-
-    describe('generics', function() {
-
-      it('should pass', function() { var list: string[] = []; });
-
-      // TODO(tbosch): add assertions based on generics to rtts_assert
-
-    });
-
-  });
-}
diff --git a/scripts/publish/npm_publish.sh b/scripts/publish/npm_publish.sh
index 8bb2ccf7fd..468749488a 100755
--- a/scripts/publish/npm_publish.sh
+++ b/scripts/publish/npm_publish.sh
@@ -14,19 +14,6 @@ rm -fr $NPM_DIR
 FILES='!(test|e2e_test|docs)'
 DTS_FILES='*.d.ts'
 
-function publishRttsAssert {
-  NAME='rtts_assert'
-  PUBLISH_DIR=$NPM_DIR/$NAME
-  rm -fr $PUBLISH_DIR
-  mkdir -p $PUBLISH_DIR
-
-  mkdir -p $PUBLISH_DIR/es6
-  cp -r $ROOT_DIR/dist/js/prod/es6/$NAME/$FILES $PUBLISH_DIR/es6
-
-  cp -r $ROOT_DIR/dist/js/cjs/$NAME/$FILES $PUBLISH_DIR
-  npm publish $PUBLISH_DIR
-}
-
 function publishModule {
   NAME=$1
   PUBLISH_DIR=$NPM_DIR/$NAME
@@ -65,6 +52,5 @@ function publishModule {
   npm publish $PUBLISH_DIR
 }
 
-publishRttsAssert
 publishModule angular2
 publishModule benchpress
diff --git a/tools/broccoli/trees/browser_tree.ts b/tools/broccoli/trees/browser_tree.ts
index 817145477d..931e4b5af2 100644
--- a/tools/broccoli/trees/browser_tree.ts
+++ b/tools/broccoli/trees/browser_tree.ts
@@ -131,10 +131,8 @@ module.exports = function makeBrowserTree(options, destinationPath) {
   });
 
   // Now we add a few more files to the es6 tree that the es5 tree should not see
-  ['angular2', 'rtts_assert'].forEach(function(destDir) {
-    var extras = new Funnel('tools/build', {files: ['es5build.js'], destDir: destDir});
-    es6Tree = mergeTrees([es6Tree, extras]);
-  });
+  var extras = new Funnel('tools/build', {files: ['es5build.js'], destDir: 'angular2'});
+  es6Tree = mergeTrees([es6Tree, extras]);
 
   var vendorScriptsTree = flatten(new Funnel('.', {
     files: [
diff --git a/tools/broccoli/trees/dart_tree.ts b/tools/broccoli/trees/dart_tree.ts
index df21d0996c..bc794740fb 100644
--- a/tools/broccoli/trees/dart_tree.ts
+++ b/tools/broccoli/trees/dart_tree.ts
@@ -14,7 +14,6 @@ import dartfmt from '../broccoli-dartfmt';
 import replace from '../broccoli-replace';
 
 var global_excludes = [
-  'rtts_assert/**/*',
   'angular2/http*',
   'angular2/src/http/**/*',
   'angular2/test/http/**/*',
@@ -57,7 +56,6 @@ function stripModulePrefix(relativePath: string): string {
 }
 
 function getSourceTree() {
-  // Transpile everything in 'modules' except for rtts_assertions.
   var tsInputTree = modulesFunnel(['**/*.js', '**/*.ts', '**/*.dart'], ['angular1_router/**/*']);
   var transpiled = ts2dart(tsInputTree, {
     generateLibraryName: true,
@@ -149,8 +147,7 @@ function getDocsTree() {
   var licenses = new MultiCopy('', {
     srcPath: 'LICENSE',
     targetPatterns: ['modules/*'],
-    exclude:
-        ['*/rtts_assert', '*/angular2/src/http', '*/upgrade', '*/angular1_router']  // Not in dart.
+    exclude: ['*/angular2/src/http', '*/upgrade', '*/angular1_router']  // Not in dart.
   });
   licenses = stew.rename(licenses, stripModulePrefix);
 
diff --git a/tools/broccoli/trees/node_tree.ts b/tools/broccoli/trees/node_tree.ts
index b1262001e5..26a53b290c 100644
--- a/tools/broccoli/trees/node_tree.ts
+++ b/tools/broccoli/trees/node_tree.ts
@@ -14,10 +14,10 @@ var projectRootDir = path.normalize(path.join(__dirname, '..', '..', '..', '..')
 
 module.exports = function makeNodeTree(destinationPath) {
   // list of npm packages that this build will create
-  var outputPackages = ['angular2', 'benchpress', 'rtts_assert'];
+  var outputPackages = ['angular2', 'benchpress'];
 
   var modulesTree = new Funnel('modules', {
-    include: ['angular2/**', 'benchpress/**', 'rtts_assert/**', '**/e2e_test/**'],
+    include: ['angular2/**', 'benchpress/**', '**/e2e_test/**'],
     exclude: [
       // the following code and tests are not compatible with CJS/node environment
       'angular2/test/core/zone/**',