diff --git a/sdk/lib/typed_data/typed_data.dart b/sdk/lib/typed_data/typed_data.dart
index c15a3f0..9c20289 100644
--- a/sdk/lib/typed_data/typed_data.dart
+++ b/sdk/lib/typed_data/typed_data.dart
@@ -10,6 +10,10 @@
 ///     import 'dart:typed_data';
 library dart.typed_data;
 
+import "dart:_internal" show UnmodifiableListBase;
+
+part "unmodifiable_typed_data.dart";
+
 /**
  * A sequence of bytes underlying a typed data object.
  *
diff --git a/sdk/lib/typed_data/typed_data_sources.gni b/sdk/lib/typed_data/typed_data_sources.gni
index daa50aa..23ba0f0 100644
--- a/sdk/lib/typed_data/typed_data_sources.gni
+++ b/sdk/lib/typed_data/typed_data_sources.gni
@@ -5,4 +5,5 @@
 typed_data_sdk_sources = [
   "typed_data.dart",
   # The above file needs to be first if additional parts are added to the lib.
+  "unmodifiable_typed_data.dart",
 ]
diff --git a/sdk/lib/typed_data/unmodifiable_typed_data.dart b/sdk/lib/typed_data/unmodifiable_typed_data.dart
new file mode 100644
index 0000000..4cc5af7
--- /dev/null
+++ b/sdk/lib/typed_data/unmodifiable_typed_data.dart
@@ -0,0 +1,303 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+part of dart.typed_data;
+
+/**
+ * A read-only view of a [ByteBuffer].
+ */
+class UnmodifiableByteBufferView implements ByteBuffer {
+  final ByteBuffer _data;
+
+  UnmodifiableByteBufferView(ByteBuffer data) : _data = data;
+
+  int get lengthInBytes => _data.lengthInBytes;
+
+  Uint8List asUint8List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableUint8ListView(_data.asUint8List(offsetInBytes, length));
+
+  Int8List asInt8List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableInt8ListView(_data.asInt8List(offsetInBytes, length));
+
+  Uint8ClampedList asUint8ClampedList([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableUint8ClampedListView(
+          _data.asUint8ClampedList(offsetInBytes, length));
+
+  Uint16List asUint16List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableUint16ListView(_data.asUint16List(offsetInBytes, length));
+
+  Int16List asInt16List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableInt16ListView(_data.asInt16List(offsetInBytes, length));
+
+  Uint32List asUint32List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableUint32ListView(_data.asUint32List(offsetInBytes, length));
+
+  Int32List asInt32List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableInt32ListView(_data.asInt32List(offsetInBytes, length));
+
+  Uint64List asUint64List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableUint64ListView(_data.asUint64List(offsetInBytes, length));
+
+  Int64List asInt64List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableInt64ListView(_data.asInt64List(offsetInBytes, length));
+
+  Int32x4List asInt32x4List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableInt32x4ListView(
+          _data.asInt32x4List(offsetInBytes, length));
+
+  Float32List asFloat32List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableFloat32ListView(
+          _data.asFloat32List(offsetInBytes, length));
+
+  Float64List asFloat64List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableFloat64ListView(
+          _data.asFloat64List(offsetInBytes, length));
+
+  Float32x4List asFloat32x4List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableFloat32x4ListView(
+          _data.asFloat32x4List(offsetInBytes, length));
+
+  Float64x2List asFloat64x2List([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableFloat64x2ListView(
+          _data.asFloat64x2List(offsetInBytes, length));
+
+  ByteData asByteData([int offsetInBytes = 0, int length]) =>
+      new UnmodifiableByteDataView(_data.asByteData(offsetInBytes, length));
+}
+
+/**
+ * A read-only view of a [ByteData].
+ */
+class UnmodifiableByteDataView implements ByteData {
+  final ByteData _data;
+
+  UnmodifiableByteDataView(ByteData data) : _data = data;
+
+  int getInt8(int byteOffset) => _data.getInt8(byteOffset);
+
+  void setInt8(int byteOffset, int value) => _unsupported();
+
+  int getUint8(int byteOffset) => _data.getUint8(byteOffset);
+
+  void setUint8(int byteOffset, int value) => _unsupported();
+
+  int getInt16(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getInt16(byteOffset, endian);
+
+  void setInt16(int byteOffset, int value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  int getUint16(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getUint16(byteOffset, endian);
+
+  void setUint16(int byteOffset, int value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  int getInt32(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getInt32(byteOffset, endian);
+
+  void setInt32(int byteOffset, int value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  int getUint32(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getUint32(byteOffset, endian);
+
+  void setUint32(int byteOffset, int value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  int getInt64(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getInt64(byteOffset, endian);
+
+  void setInt64(int byteOffset, int value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  int getUint64(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getUint64(byteOffset, endian);
+
+  void setUint64(int byteOffset, int value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  double getFloat32(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getFloat32(byteOffset, endian);
+
+  void setFloat32(int byteOffset, double value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  double getFloat64(int byteOffset, [Endian endian = Endian.big]) =>
+      _data.getFloat64(byteOffset, endian);
+
+  void setFloat64(int byteOffset, double value, [Endian endian = Endian.big]) =>
+      _unsupported();
+
+  int get elementSizeInBytes => _data.elementSizeInBytes;
+
+  int get offsetInBytes => _data.offsetInBytes;
+
+  int get lengthInBytes => _data.lengthInBytes;
+
+  ByteBuffer get buffer => new UnmodifiableByteBufferView(_data.buffer);
+
+  void _unsupported() {
+    throw new UnsupportedError(
+        "An UnmodifiableByteDataView may not be modified");
+  }
+}
+
+abstract class _UnmodifiableListMixin<N, L extends List<N>,
+    TD extends TypedData> {
+  L get _list;
+  TD get _data => (_list as TD);
+
+  int get length => _list.length;
+
+  N operator [](int index) => _list[index];
+
+  int get elementSizeInBytes => _data.elementSizeInBytes;
+
+  int get offsetInBytes => _data.offsetInBytes;
+
+  int get lengthInBytes => _data.lengthInBytes;
+
+  ByteBuffer get buffer => new UnmodifiableByteBufferView(_data.buffer);
+}
+
+/**
+ * View of a [Uint8List] that disallows modification.
+ */
+class UnmodifiableUint8ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Uint8List, Uint8List>
+    implements Uint8List {
+  final Uint8List _list;
+  UnmodifiableUint8ListView(Uint8List list) : _list = list;
+}
+
+/**
+ * View of a [Int8List] that disallows modification.
+ */
+class UnmodifiableInt8ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Int8List, Int8List>
+    implements Int8List {
+  final Int8List _list;
+  UnmodifiableInt8ListView(Int8List list) : _list = list;
+}
+
+/**
+ * View of a [Uint8ClampedList] that disallows modification.
+ */
+class UnmodifiableUint8ClampedListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Uint8ClampedList, Uint8ClampedList>
+    implements Uint8ClampedList {
+  final Uint8ClampedList _list;
+  UnmodifiableUint8ClampedListView(Uint8ClampedList list) : _list = list;
+}
+
+/**
+ * View of a [Uint16List] that disallows modification.
+ */
+class UnmodifiableUint16ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Uint16List, Uint16List>
+    implements Uint16List {
+  final Uint16List _list;
+  UnmodifiableUint16ListView(Uint16List list) : _list = list;
+}
+
+/**
+ * View of a [Int16List] that disallows modification.
+ */
+class UnmodifiableInt16ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Int16List, Int16List>
+    implements Int16List {
+  final Int16List _list;
+  UnmodifiableInt16ListView(Int16List list) : _list = list;
+}
+
+/**
+ * View of a [Uint32List] that disallows modification.
+ */
+class UnmodifiableUint32ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Uint32List, Uint32List>
+    implements Uint32List {
+  final Uint32List _list;
+  UnmodifiableUint32ListView(Uint32List list) : _list = list;
+}
+
+/**
+ * View of a [Int32List] that disallows modification.
+ */
+class UnmodifiableInt32ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Int32List, Int32List>
+    implements Int32List {
+  final Int32List _list;
+  UnmodifiableInt32ListView(Int32List list) : _list = list;
+}
+
+/**
+ * View of a [Uint64List] that disallows modification.
+ */
+class UnmodifiableUint64ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Uint64List, Uint64List>
+    implements Uint64List {
+  final Uint64List _list;
+  UnmodifiableUint64ListView(Uint64List list) : _list = list;
+}
+
+/**
+ * View of a [Int64List] that disallows modification.
+ */
+class UnmodifiableInt64ListView extends UnmodifiableListBase<int>
+    with _UnmodifiableListMixin<int, Int64List, Int64List>
+    implements Int64List {
+  final Int64List _list;
+  UnmodifiableInt64ListView(Int64List list) : _list = list;
+}
+
+/**
+ * View of a [Int32x4List] that disallows modification.
+ */
+class UnmodifiableInt32x4ListView extends UnmodifiableListBase<Int32x4>
+    with _UnmodifiableListMixin<Int32x4, Int32x4List, Int32x4List>
+    implements Int32x4List {
+  final Int32x4List _list;
+  UnmodifiableInt32x4ListView(Int32x4List list) : _list = list;
+}
+
+/**
+ * View of a [Float32x4List] that disallows modification.
+ */
+class UnmodifiableFloat32x4ListView extends UnmodifiableListBase<Float32x4>
+    with _UnmodifiableListMixin<Float32x4, Float32x4List, Float32x4List>
+    implements Float32x4List {
+  final Float32x4List _list;
+  UnmodifiableFloat32x4ListView(Float32x4List list) : _list = list;
+}
+
+/**
+ * View of a [Float64x2List] that disallows modification.
+ */
+class UnmodifiableFloat64x2ListView extends UnmodifiableListBase<Float64x2>
+    with _UnmodifiableListMixin<Float64x2, Float64x2List, Float64x2List>
+    implements Float64x2List {
+  final Float64x2List _list;
+  UnmodifiableFloat64x2ListView(Float64x2List list) : _list = list;
+}
+
+/**
+ * View of a [Float32List] that disallows modification.
+ */
+class UnmodifiableFloat32ListView extends UnmodifiableListBase<double>
+    with _UnmodifiableListMixin<double, Float32List, Float32List>
+    implements Float32List {
+  final Float32List _list;
+  UnmodifiableFloat32ListView(Float32List list) : _list = list;
+}
+
+/**
+ * View of a [Float64List] that disallows modification.
+ */
+class UnmodifiableFloat64ListView extends UnmodifiableListBase<double>
+    with _UnmodifiableListMixin<double, Float64List, Float64List>
+    implements Float64List {
+  final Float64List _list;
+  UnmodifiableFloat64ListView(Float64List list) : _list = list;
+}
diff --git a/tests/lib_2/lib_2_dart2js.status b/tests/lib_2/lib_2_dart2js.status
index 21b3a73..87a6273 100644
--- a/tests/lib_2/lib_2_dart2js.status
+++ b/tests/lib_2/lib_2_dart2js.status
@@ -68,6 +68,7 @@
 typed_data/int32x4_arithmetic_test/int64: RuntimeError # Issue 1533
 typed_data/int64_list_load_store_test: RuntimeError # Issue 10275
 typed_data/typed_data_hierarchy_int64_test: RuntimeError # Issue 10275
+typed_data/unmodifiable_typed_data_test: RuntimeError # Issue 10275
 
 [ $compiler != dart2js ]
 async/dart2js_uncaught_error_test: Skip # JS-integration only test
diff --git a/tests/lib_2/lib_2_dartdevc.status b/tests/lib_2/lib_2_dartdevc.status
index dd36b16..c90982c 100644
--- a/tests/lib_2/lib_2_dartdevc.status
+++ b/tests/lib_2/lib_2_dartdevc.status
@@ -130,4 +130,4 @@
 typed_data/int32x4_arithmetic_test/int64: RuntimeError # Issue 29922
 typed_data/int64_list_load_store_test: RuntimeError # Issue 29922
 typed_data/typed_data_hierarchy_int64_test: RuntimeError # Issue 29922
-
+typed_data/unmodifiable_typed_data_test: RuntimeError # Issue 10275
diff --git a/tests/lib_2/typed_data/unmodifiable_typed_data_test.dart b/tests/lib_2/typed_data/unmodifiable_typed_data_test.dart
new file mode 100644
index 0000000..70708c5
--- /dev/null
+++ b/tests/lib_2/typed_data/unmodifiable_typed_data_test.dart
@@ -0,0 +1,165 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:typed_data';
+import 'package:expect/expect.dart';
+
+List<int> intList = <int>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+checkReadable(List<int> list) {
+  for (int i = 0; i < intList.length; i++) {
+    Expect.equals(list[i], intList[i]);
+  }
+}
+
+checkUnmodifiable(List<int> list) {
+  var zero = 0;
+  var one = 1;
+  var two = 2;
+  Expect.throwsUnsupportedError(() => list.add(zero));
+  Expect.throwsUnsupportedError(() => list.addAll([one, two]));
+  Expect.throwsUnsupportedError(() => list.clear());
+  Expect.throwsUnsupportedError(() => list.insert(0, zero));
+  Expect.throwsUnsupportedError(() => list.insertAll(0, [one, two]));
+  Expect.throwsUnsupportedError(() => list.remove(one));
+  Expect.throwsUnsupportedError(() => list.removeAt(0));
+  Expect.throwsUnsupportedError(() => list.removeLast());
+  Expect.throwsUnsupportedError(() => list.removeRange(0, 1));
+  Expect.throwsUnsupportedError(() => list.removeWhere((x) => true));
+  Expect.throwsUnsupportedError(() => list.replaceRange(0, 1, []));
+  Expect.throwsUnsupportedError(() => list.retainWhere((x) => false));
+  Expect.throwsUnsupportedError(() => list[0] = zero);
+  Expect.throwsUnsupportedError(() => list.setRange(0, 1, [one]));
+  Expect.throwsUnsupportedError(() => list.setAll(0, [one]));
+}
+
+int8ListTest() {
+  Int8List i8l = new Int8List.fromList(intList);
+  UnmodifiableInt8ListView list = new UnmodifiableInt8ListView(i8l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+uint8ListTest() {
+  Uint8List u8l = new Uint8List.fromList(intList);
+  UnmodifiableUint8ListView list = new UnmodifiableUint8ListView(u8l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+int16ListTest() {
+  Int16List i16l = new Int16List.fromList(intList);
+  UnmodifiableInt16ListView list = new UnmodifiableInt16ListView(i16l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+uint16ListTest() {
+  Uint16List u16l = new Uint16List.fromList(intList);
+  UnmodifiableUint16ListView list = new UnmodifiableUint16ListView(u16l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+int32ListTest() {
+  Int32List i32l = new Int32List.fromList(intList);
+  UnmodifiableInt32ListView list = new UnmodifiableInt32ListView(i32l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+uint32ListTest() {
+  Uint32List u32l = new Uint32List.fromList(intList);
+  UnmodifiableUint32ListView list = new UnmodifiableUint32ListView(u32l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+int64ListTest() {
+  Int64List i64l = new Int64List.fromList(intList);
+  UnmodifiableInt64ListView list = new UnmodifiableInt64ListView(i64l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+uint64ListTest() {
+  Uint64List u64l = new Uint64List.fromList(intList);
+  UnmodifiableUint64ListView list = new UnmodifiableUint64ListView(u64l);
+  checkReadable(list);
+  checkUnmodifiable(list);
+}
+
+List<double> doubleList = <double>[1.0, 2.0, 3.0, 4.0, 5.0];
+
+checkDoubleReadable(List<double> list) {
+  for (int i = 0; i < doubleList.length; i++) {
+    Expect.equals(list[i], doubleList[i]);
+  }
+}
+
+checkDoubleUnmodifiable(List<double> list) {
+  var zero = 0.0;
+  var one = 1.0;
+  var two = 2.0;
+  Expect.throwsUnsupportedError(() => list.add(zero));
+  Expect.throwsUnsupportedError(() => list.addAll([one, two]));
+  Expect.throwsUnsupportedError(() => list.clear());
+  Expect.throwsUnsupportedError(() => list.insert(0, zero));
+  Expect.throwsUnsupportedError(() => list.insertAll(0, [one, two]));
+  Expect.throwsUnsupportedError(() => list.remove(one));
+  Expect.throwsUnsupportedError(() => list.removeAt(0));
+  Expect.throwsUnsupportedError(() => list.removeLast());
+  Expect.throwsUnsupportedError(() => list.removeRange(0, 1));
+  Expect.throwsUnsupportedError(() => list.removeWhere((x) => true));
+  Expect.throwsUnsupportedError(() => list.replaceRange(0, 1, []));
+  Expect.throwsUnsupportedError(() => list.retainWhere((x) => false));
+  Expect.throwsUnsupportedError(() => list[0] = zero);
+  Expect.throwsUnsupportedError(() => list.setRange(0, 1, [one]));
+  Expect.throwsUnsupportedError(() => list.setAll(0, [one]));
+}
+
+float32ListTest() {
+  Float32List f32l = new Float32List.fromList(doubleList);
+  UnmodifiableFloat32ListView list = new UnmodifiableFloat32ListView(f32l);
+  checkDoubleReadable(list);
+  checkDoubleUnmodifiable(list);
+}
+
+float64ListTest() {
+  Float64List f64l = new Float64List.fromList(doubleList);
+  UnmodifiableFloat64ListView list = new UnmodifiableFloat64ListView(f64l);
+  checkDoubleReadable(list);
+  checkDoubleUnmodifiable(list);
+}
+
+byteDataTest() {
+  ByteBuffer buffer = new Uint8List.fromList(intList).buffer;
+  ByteData bd = new ByteData.view(buffer);
+  UnmodifiableByteDataView ubdv = new UnmodifiableByteDataView(bd);
+
+  Expect.throwsUnsupportedError(() => ubdv.setInt8(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setUint8(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setInt16(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setUint16(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setInt32(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setUint32(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setInt64(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setUint64(0, 0));
+  Expect.throwsUnsupportedError(() => ubdv.setFloat32(0, 0.0));
+  Expect.throwsUnsupportedError(() => ubdv.setFloat64(0, 0.0));
+}
+
+main() {
+  int8ListTest();
+  uint8ListTest();
+  int16ListTest();
+  uint16ListTest();
+  int32ListTest();
+  uint32ListTest();
+  int64ListTest();
+  uint64ListTest();
+  float32ListTest();
+  float64ListTest();
+  byteDataTest();
+}