diff --git a/include/utils/SkJSON.h b/include/utils/SkJSON.h
new file mode 100644
index 0000000..44826ac
--- /dev/null
+++ b/include/utils/SkJSON.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJSON_DEFINED
+#define SkJSON_DEFINED
+
+#include "SkTypes.h"
+
+class SkString;
+
+class SkJSON {
+public:
+    enum Type {
+        kObject,
+        kArray,
+        kString,
+        kInt,
+        kFloat,
+        kBool,
+    };
+    
+    class Array;
+    
+    class Object {
+    public:
+        Object() : fHead(NULL), fTail(NULL) {}
+        Object(const Object&);
+        ~Object();
+        
+        void addObject(const char name[], Object* value);
+        void addArray(const char name[], Array* value);
+        void addString(const char name[], const char value[]);
+        void addInt(const char name[], int32_t value);
+        void addFloat(const char name[], float value);
+        void addBool(const char name[], bool value);
+        
+        bool findObject(const char name[], Object** = NULL) const;
+        bool findArray(const char name[], Array** = NULL) const;
+        bool findString(const char name[], SkString* = NULL) const;
+        bool findInt(const char name[], int32_t* = NULL) const;
+        bool findFloat(const char name[], float* = NULL) const;
+        bool findBool(const char name[], bool* = NULL) const;
+        
+        void dump() const;
+        
+    private:
+        struct Slot;
+        Slot* fHead;
+        Slot* fTail;
+        
+        const Slot* findSlot(const char name[]) const;
+        const Slot* findSlotAndType(const char name[], Type) const;
+        Slot* addSlot(Slot*);
+        void dumpLevel(int level) const;
+        
+        friend class Array;
+    };
+    
+    class Array {
+    public:
+        // do I support strings, objects, arrays?
+        Array(Type, int count);
+        Array(const int32_t values[], int count);
+        Array(const float values[], int count);
+        Array(const bool values[], int count);
+        Array(const Array&);
+        ~Array();
+        
+        int count() const { return fCount; }
+        Type type() const { return fType; }
+        
+        int32_t* ints() const { return fArray.fInts; }
+        float* floats() const { return fArray.fFloats; }
+        bool* bools() const { return fArray.fBools; }
+        
+    private:
+        int fCount;
+        Type fType;
+        union {
+            void*    fVoids;
+            int32_t* fInts;
+            float*   fFloats;
+            bool*    fBools;
+        } fArray;
+        
+        void init(Type, int count, const void* src);
+        void dumpLevel(int level) const;
+        
+        friend class Object;
+    };
+};
+
+#endif
diff --git a/src/utils/SkJSON.cpp b/src/utils/SkJSON.cpp
new file mode 100644
index 0000000..acdc9a7
--- /dev/null
+++ b/src/utils/SkJSON.cpp
@@ -0,0 +1,334 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkJSON.h"
+#include "SkString.h"
+
+struct SkJSON::Object::Slot {
+    Slot(const char name[], Type type) {
+        fNext = NULL;
+        
+        size_t len = strlen(name);
+        char* str = new char[len + 2];
+        str[0] = (char)type;
+        memcpy(str + 1, name, len + 1);
+        fName = str;
+        
+        // fValue is uninitialized
+    }
+    ~Slot();
+    
+    const char* name() const {
+        return fName ? &fName[1] : "";
+    }
+    
+    Type type() const {
+        return (Type)fName[0];
+    }
+    
+    Slot*   fNext;
+    char*   fName;    // fName[0] is the type
+    union {
+        SkJSON::Object* fObject;
+        SkJSON::Array*  fArray;
+        char*           fString;
+        int32_t         fInt;
+        float           fFloat;
+        bool            fBool;
+        intptr_t        fIntPtr;    // for generic getter
+    } fValue;
+};
+
+SkJSON::Object::Slot::~Slot() {
+    switch (this->type()) {
+        case kObject:
+            delete fValue.fObject;
+            break;
+        case kArray:
+        case kString:
+            delete[] fValue.fString;
+            break;
+        default:
+            break;
+    }
+    delete[] fName;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkJSON::Object::~Object() {
+    Slot* slot = fHead;
+    while (slot) {
+        Slot* next = slot->fNext;
+        delete slot;
+        slot = next;
+    }
+}
+
+SkJSON::Object::Slot* SkJSON::Object::addSlot(Slot* slot) {
+    SkASSERT(NULL == slot->fNext);
+    if (NULL == fHead) {
+        SkASSERT(NULL == fTail);
+        fHead = fTail = slot;
+    } else {
+        SkASSERT(fTail);
+        SkASSERT(NULL == fTail->fNext);
+        fTail->fNext = slot;
+        fTail = slot;
+    }
+}
+
+void SkJSON::Object::addObject(const char name[], SkJSON::Object* value) {
+    Slot* slot = addSlot(new Slot(name, kObject));
+    fTail->fValue.fObject = value;
+}
+
+void SkJSON::Object::addArray(const char name[], SkJSON::Array* value) {
+    Slot* slot = addSlot(new Slot(name, kArray));
+    fTail->fValue.fArray = value;
+}
+
+void SkJSON::Object::addString(const char name[], const char value[]) {
+    Slot* slot = addSlot(new Slot(name, kString));
+    size_t len = strlen(value);
+    char* str = new char[len + 1];
+    memcpy(str, value, len + 1);
+    slot->fValue.fString = str;
+}
+
+void SkJSON::Object::addInt(const char name[], int32_t value) {
+    Slot* slot = addSlot(new Slot(name, kInt));
+    fTail->fValue.fInt = value;
+}
+
+void SkJSON::Object::addFloat(const char name[], float value) {
+    Slot* slot = addSlot(new Slot(name, kFloat));
+    fTail->fValue.fFloat = value;
+}
+
+void SkJSON::Object::addBool(const char name[], bool value) {
+    Slot* slot = addSlot(new Slot(name, kBool));
+    fTail->fValue.fBool = value;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const SkJSON::Object::Slot* SkJSON::Object::findSlot(const char name[]) const {
+    for (const Slot* slot = fHead; slot; slot = slot->fNext) {
+        if (!strcmp(slot->name(), name)) {
+            return slot;
+        }
+    }
+    return NULL;
+}
+
+const SkJSON::Object::Slot* SkJSON::Object::findSlotAndType(const char name[],
+                                                        Type t) const {
+    const Slot* slot = this->findSlot(name);
+    if (slot && (slot->type() != t)) {
+        slot = NULL;
+    }
+    return slot;
+}
+
+bool SkJSON::Object::findString(const char name[], SkString* value) const {
+    const Slot* slot = this->findSlotAndType(name, kString);
+    if (slot) {
+        if (value) {
+            value->set(slot->fValue.fString);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SkJSON::Object::findInt(const char name[], int32_t* value) const {
+    const Slot* slot = this->findSlotAndType(name, kInt);
+    if (slot) {
+        if (value) {
+            *value = slot->fValue.fInt;
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SkJSON::Object::findFloat(const char name[], float* value) const {
+    const Slot* slot = this->findSlotAndType(name, kFloat);
+    if (slot) {
+        if (value) {
+            *value = slot->fValue.fFloat;
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SkJSON::Object::findBool(const char name[], bool* value) const {
+    const Slot* slot = this->findSlotAndType(name, kBool);
+    if (slot) {
+        if (value) {
+            *value = slot->fValue.fBool;
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SkJSON::Object::findObject(const char name[], SkJSON::Object** value) const {
+    const Slot* slot = this->findSlotAndType(name, kObject);
+    if (slot) {
+        if (value) {
+            *value = slot->fValue.fObject;
+        }
+        return true;
+    }
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void tabForLevel(int level) {
+    for (int i = 0; i < level; ++i) {
+        SkDebugf("    ");
+    }
+}
+
+void SkJSON::Object::dump() const {
+    SkDebugf("{\n");
+    this->dumpLevel(0);
+    SkDebugf("}\n");
+}
+
+void SkJSON::Object::dumpLevel(int level) const {
+    for (Slot* slot = fHead; slot; slot = slot->fNext) {
+        Type t = slot->type();        
+        tabForLevel(level + 1);
+        SkDebugf("\"%s\" : ", slot->name());
+        switch (slot->type()) {
+            case kObject:
+                if (slot->fValue.fObject) {
+                    SkDebugf("{\n");
+                    slot->fValue.fObject->dumpLevel(level + 1);
+                    tabForLevel(level + 1);
+                    SkDebugf("}");
+                } else {
+                    SkDebugf("null");
+                }
+                break;
+            case kArray:
+                if (slot->fValue.fArray) {
+                    SkDebugf("[");
+                    slot->fValue.fArray->dumpLevel(level + 1);
+                    SkDebugf("]");
+                } else {
+                    SkDebugf("null");
+                }
+                break;
+            case kString:
+                SkDebugf("\"%s\"", slot->fValue.fString);
+                break;
+            case kInt:
+                SkDebugf("%d", slot->fValue.fInt);
+                break;
+            case kFloat:
+                SkDebugf("%g", slot->fValue.fFloat);
+                break;
+            case kBool:
+                SkDebugf("%s", slot->fValue.fBool ? "true" : "false");
+                break;
+            default:
+                SkASSERT(!"how did I get here");
+                break;
+        }
+        if (slot->fNext) {
+            SkDebugf(",");
+        }
+        SkDebugf("\n");
+    }
+}
+
+void SkJSON::Array::dumpLevel(int level) const {
+    if (0 == fCount) {
+        return;
+    }
+    int last = fCount - 1;
+
+    switch (this->type()) {
+        case kInt: {
+            for (int i = 0; i < last; ++i) {
+                SkDebugf(" %d,", fArray.fInts[i]);
+            }
+            SkDebugf(" %d ", fArray.fInts[last]);
+        } break;
+        case kFloat: {
+            for (int i = 0; i < last; ++i) {
+                SkDebugf(" %g,", fArray.fFloats[i]);
+            }
+            SkDebugf(" %g ", fArray.fFloats[last]);
+        } break;
+        case kBool: {
+            for (int i = 0; i < last; ++i) {
+                SkDebugf(" %s,", fArray.fBools[i] ? "true" : "false");
+            }
+            SkDebugf(" %s ", fArray.fInts[last] ? "true" : "false");
+        } break;
+        default:
+            SkASSERT(!"unsupported array type");
+            break;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const uint8_t gBytesPerType[] = {
+    sizeof(SkJSON::Object*),
+    sizeof(SkJSON::Array*),
+    sizeof(char*),
+    sizeof(int32_t),
+    sizeof(float),
+    sizeof(bool)
+};
+
+void SkJSON::Array::init(Type type, int count, const void* src) {
+    if (count < 0) {
+        count = 0;
+    }
+    size_t size = count * gBytesPerType[type];
+
+    fCount = count;
+    fType = type;
+    fArray.fVoids = sk_malloc_throw(size);
+    if (src) {
+        memcpy(fArray.fVoids, src, size);
+    }
+}
+
+SkJSON::Array::Array(Type type, int count) {
+    this->init(type, count, NULL);
+}
+
+SkJSON::Array::Array(const int32_t values[], int count) {
+    this->init(kInt, count, values);
+}
+    
+SkJSON::Array::Array(const float values[], int count) {
+    this->init(kFloat, count, values);
+}
+
+SkJSON::Array::Array(const bool values[], int count) {
+    this->init(kBool, count, values);
+}
+
+SkJSON::Array::Array(const Array& src) {
+    this->init(src.type(), src.count(), src.fArray.fVoids);
+}
+
+SkJSON::Array::~Array() {
+    sk_free(fArray.fVoids);
+}
+