diff --git a/include/core/SkColor.h b/include/core/SkColor.h
index 90453f5..b1571c7 100644
--- a/include/core/SkColor.h
+++ b/include/core/SkColor.h
@@ -180,6 +180,11 @@
 
     static SkPM4f FromPMColor(SkPMColor);
 
+    // half-float routines
+    void toF16(uint16_t[4]) const;
+    uint64_t toF16() const; // 4 float16 values packed into uint64_t
+    static SkPM4f FromF16(const uint16_t[4]);
+
 #ifdef SK_DEBUG
     void assertIsUnit() const;
 #else
diff --git a/include/core/SkImageInfo.h b/include/core/SkImageInfo.h
index 4b82ae6..b2dda3f 100644
--- a/include/core/SkImageInfo.h
+++ b/include/core/SkImageInfo.h
@@ -73,8 +73,9 @@
     kBGRA_8888_SkColorType,
     kIndex_8_SkColorType,
     kGray_8_SkColorType,
+    kRGBA_F16_SkColorType,
 
-    kLastEnum_SkColorType = kGray_8_SkColorType,
+    kLastEnum_SkColorType = kRGBA_F16_SkColorType,
 
 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
     kN32_SkColorType = kBGRA_8888_SkColorType,
@@ -95,6 +96,7 @@
         4,  // BGRA_8888
         1,  // kIndex_8
         1,  // kGray_8
+        8,  // kRGBA_F16
     };
     static_assert(SK_ARRAY_COUNT(gSize) == (size_t)(kLastEnum_SkColorType + 1),
                   "size_mismatch_with_SkColorType_enum");
@@ -114,6 +116,7 @@
 static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) {
     int shift = 0;
     switch (SkColorTypeBytesPerPixel(ct)) {
+        case 8: shift = 3; break;
         case 4: shift = 2; break;
         case 2: shift = 1; break;
         case 1: shift = 0; break;
diff --git a/include/core/SkPixmap.h b/include/core/SkPixmap.h
index 523c40f..894b238 100644
--- a/include/core/SkPixmap.h
+++ b/include/core/SkPixmap.h
@@ -75,51 +75,75 @@
     uint64_t getSafeSize64() const { return fInfo.getSafeSize64(fRowBytes); }
     size_t getSafeSize() const { return fInfo.getSafeSize(fRowBytes); }
 
-    const uint32_t* addr32() const {
-        SkASSERT(4 == SkColorTypeBytesPerPixel(fInfo.colorType()));
-        return reinterpret_cast<const uint32_t*>(fPixels);
+    const void* addr(int x, int y) const {
+        return (const char*)fPixels + fInfo.computeOffset(x, y, fRowBytes);
     }
-
-    const uint16_t* addr16() const {
-        SkASSERT(2 == SkColorTypeBytesPerPixel(fInfo.colorType()));
-        return reinterpret_cast<const uint16_t*>(fPixels);
-    }
-
     const uint8_t* addr8() const {
         SkASSERT(1 == SkColorTypeBytesPerPixel(fInfo.colorType()));
         return reinterpret_cast<const uint8_t*>(fPixels);
     }
+    const uint16_t* addr16() const {
+        SkASSERT(2 == SkColorTypeBytesPerPixel(fInfo.colorType()));
+        return reinterpret_cast<const uint16_t*>(fPixels);
+    }
+    const uint32_t* addr32() const {
+        SkASSERT(4 == SkColorTypeBytesPerPixel(fInfo.colorType()));
+        return reinterpret_cast<const uint32_t*>(fPixels);
+    }
+    const uint64_t* addr64() const {
+        SkASSERT(8 == SkColorTypeBytesPerPixel(fInfo.colorType()));
+        return reinterpret_cast<const uint64_t*>(fPixels);
+    }
+    const uint16_t* addrF16() const {
+        SkASSERT(8 == SkColorTypeBytesPerPixel(fInfo.colorType()));
+        SkASSERT(kRGBA_F16_SkColorType == fInfo.colorType());
+        return reinterpret_cast<const uint16_t*>(fPixels);
+    }
 
-    const uint32_t* addr32(int x, int y) const {
+    // Offset by the specified x,y coordinates
+
+    const uint8_t* addr8(int x, int y) const {
         SkASSERT((unsigned)x < (unsigned)fInfo.width());
         SkASSERT((unsigned)y < (unsigned)fInfo.height());
-        return (const uint32_t*)((const char*)this->addr32() + y * fRowBytes + (x << 2));
+        return (const uint8_t*)((const char*)this->addr8() + y * fRowBytes + (x << 0));
     }
     const uint16_t* addr16(int x, int y) const {
         SkASSERT((unsigned)x < (unsigned)fInfo.width());
         SkASSERT((unsigned)y < (unsigned)fInfo.height());
         return (const uint16_t*)((const char*)this->addr16() + y * fRowBytes + (x << 1));
     }
-    const uint8_t* addr8(int x, int y) const {
+    const uint32_t* addr32(int x, int y) const {
         SkASSERT((unsigned)x < (unsigned)fInfo.width());
         SkASSERT((unsigned)y < (unsigned)fInfo.height());
-        return (const uint8_t*)((const char*)this->addr8() + y * fRowBytes + (x << 0));
+        return (const uint32_t*)((const char*)this->addr32() + y * fRowBytes + (x << 2));
     }
-    const void* addr(int x, int y) const {
-        return (const char*)fPixels + fInfo.computeOffset(x, y, fRowBytes);
+    const uint64_t* addr64(int x, int y) const {
+        SkASSERT((unsigned)x < (unsigned)fInfo.width());
+        SkASSERT((unsigned)y < (unsigned)fInfo.height());
+        return (const uint64_t*)((const char*)this->addr64() + y * fRowBytes + (x << 3));
+    }
+    const uint16_t* addrF16(int x, int y) const {
+        SkASSERT(kRGBA_F16_SkColorType == fInfo.colorType());
+        return reinterpret_cast<const uint16_t*>(this->addr64(x, y));
     }
 
     // Writable versions
 
     void* writable_addr() const { return const_cast<void*>(fPixels); }
-    uint32_t* writable_addr32(int x, int y) const {
-        return const_cast<uint32_t*>(this->addr32(x, y));
+    uint8_t* writable_addr8(int x, int y) const {
+        return const_cast<uint8_t*>(this->addr8(x, y));
     }
     uint16_t* writable_addr16(int x, int y) const {
         return const_cast<uint16_t*>(this->addr16(x, y));
     }
-    uint8_t* writable_addr8(int x, int y) const {
-        return const_cast<uint8_t*>(this->addr8(x, y));
+    uint32_t* writable_addr32(int x, int y) const {
+        return const_cast<uint32_t*>(this->addr32(x, y));
+    }
+    uint64_t* writable_addr64(int x, int y) const {
+        return const_cast<uint64_t*>(this->addr64(x, y));
+    }
+    uint16_t* writable_addrF16(int x, int y) const {
+        return reinterpret_cast<uint16_t*>(writable_addr64(x, y));
     }
 
     // copy methods
@@ -152,6 +176,7 @@
     bool erase(SkColor, const SkIRect& subset) const;
 
     bool erase(SkColor color) const { return this->erase(color, this->bounds()); }
+    bool erase(const SkColor4f&, const SkIRect* subset = nullptr) const;
 
 private:
     const void*     fPixels;
diff --git a/src/core/SkColor.cpp b/src/core/SkColor.cpp
index 87e3a9d..c0a3895 100644
--- a/src/core/SkColor.cpp
+++ b/src/core/SkColor.cpp
@@ -103,6 +103,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 #include "SkNx.h"
+#include "SkHalf.h"
 
 SkPM4f SkPM4f::FromPMColor(SkPMColor c) {
     Sk4f value = SkNx_cast<float>(Sk4b::Load(&c));
@@ -121,6 +122,36 @@
     }
 }
 
+void SkPM4f::toF16(uint16_t half[4]) const {
+    for (int i = 0; i < 4; ++i) {
+        half[i] = SkFloatToHalf(fVec[i]);
+    }
+}
+
+uint64_t SkPM4f::toF16() const {
+    uint64_t value;
+    this->toF16(reinterpret_cast<uint16_t*>(&value));
+    return value;
+}
+
+SkPM4f SkPM4f::FromF16(const uint16_t half[4]) {
+    return {{
+        SkHalfToFloat(half[0]),
+        SkHalfToFloat(half[1]),
+        SkHalfToFloat(half[2]),
+        SkHalfToFloat(half[3])
+    }};
+}
+
+#ifdef SK_DEBUG
+void SkPM4f::assertIsUnit() const {
+    auto c4 = Sk4f::Load(fVec);
+    SkASSERT((c4 >= Sk4f(0)).allTrue() && (c4 <= Sk4f(1)).allTrue());
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 SkColor4f SkColor4f::FromColor(SkColor c) {
     Sk4f value = SkNx_shuffle<3,2,1,0>(SkNx_cast<float>(Sk4b::Load(&c)));
     SkColor4f c4;
@@ -151,10 +182,3 @@
     dst.store(&pm4);
     return pm4;
 }
-
-#ifdef SK_DEBUG
-void SkPM4f::assertIsUnit() const {
-    auto c4 = Sk4f::Load(fVec);
-    SkASSERT((c4 >= Sk4f(0)).allTrue() && (c4 <= Sk4f(1)).allTrue());
-}
-#endif
diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp
index e2d4d30..f285668 100644
--- a/src/core/SkPixmap.cpp
+++ b/src/core/SkPixmap.cpp
@@ -207,6 +207,41 @@
     return true;
 }
 
+#include "SkNx.h"
+#include "SkHalf.h"
+
+static void sk_memset64(uint64_t dst[], uint64_t value, int count) {
+    for (int i = 0; i < count; ++i) {
+        dst[i] = value;
+    }
+}
+
+bool SkPixmap::erase(const SkColor4f& origColor, const SkIRect* subset) const {
+    SkPixmap pm;
+    if (subset) {
+        if (!this->extractSubset(&pm, *subset)) {
+            return false;
+        }
+    } else {
+        pm = *this;
+    }
+
+    const SkColor4f color = origColor.pin();
+
+    if (kRGBA_F16_SkColorType != pm.colorType()) {
+        Sk4f c4 = Sk4f::Load(color.vec());
+        SkColor c;
+        (c4 * Sk4f(255) + Sk4f(0.5f)).store(&c);
+        return pm.erase(c);
+    }
+
+    const uint64_t half4 = color.premul().toF16();
+    for (int y = 0; y < pm.height(); ++y) {
+        sk_memset64(pm.writable_addr64(0, y), half4, pm.width());
+    }
+    return true;
+}
+
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkSurface.h"
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 62b7ff1..e4dc467 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -318,6 +318,8 @@
             return kIndex_8_GrPixelConfig;
         case kGray_8_SkColorType:
             return kAlpha_8_GrPixelConfig; // TODO: gray8 support on gpu
+        case kRGBA_F16_SkColorType:
+            return kRGBA_half_GrPixelConfig;
     }
     SkASSERT(0);    // shouldn't get here
     return kUnknown_GrPixelConfig;
diff --git a/tests/Float16Test.cpp b/tests/Float16Test.cpp
new file mode 100644
index 0000000..0a2c3d5
--- /dev/null
+++ b/tests/Float16Test.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Test.h"
+#include "SkColor.h"
+#include "SkHalf.h"
+#include "SkPixmap.h"
+
+static bool eq_within_half_float(float a, float b) {
+    const float kTolerance = 1.0f / (1 << (8 + 10));
+
+    SkHalf ha = SkFloatToHalf(a);
+    SkHalf hb = SkFloatToHalf(b);
+    float a2 = SkHalfToFloat(ha);
+    float b2 = SkHalfToFloat(hb);
+    return fabsf(a2 - b2) <= kTolerance;
+}
+
+static bool eq_within_half_float(const SkPM4f& a, const SkPM4f& b) {
+    for (int i = 0; i < 4; ++i) {
+        if (!eq_within_half_float(a.fVec[i], b.fVec[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+DEF_TEST(color_half_float, reporter) {
+    const int w = 100;
+    const int h = 100;
+
+    SkImageInfo info = SkImageInfo::Make(w, h, kRGBA_F16_SkColorType, kPremul_SkAlphaType);
+
+    SkAutoPixmapStorage pm;
+    pm.alloc(info);
+    REPORTER_ASSERT(reporter, pm.getSafeSize() == SkToSizeT(w * h * sizeof(uint64_t)));
+
+    SkColor4f c4 { 0.5f, 1, 0.5f, 0.25f };
+    pm.erase(c4);
+
+    SkPM4f origpm4 = c4.premul();
+    for (int y = 0; y < pm.height(); ++y) {
+        for (int x = 0; x < pm.width(); ++x) {
+            SkPM4f pm4 = SkPM4f::FromF16(pm.addrF16(x, y));
+            REPORTER_ASSERT(reporter, eq_within_half_float(origpm4, pm4));
+        }
+    }
+}