diff --git a/rsAllocation.cpp b/rsAllocation.cpp
index 0c271c1..057ce6f 100644
--- a/rsAllocation.cpp
+++ b/rsAllocation.cpp
@@ -236,13 +236,14 @@
 
 void Allocation::dumpLOGV(const char *prefix) const {
     ObjectBase::dumpLOGV(prefix);
+    char buf[1024];
 
-    String8 s(prefix);
-    s.append(" type ");
-    if (mHal.state.type) {
-        mHal.state.type->dumpLOGV(s.string());
+    if ((strlen(prefix) + 10) < sizeof(buf)) {
+        sprintf(buf, "%s type ", prefix);
+        if (mHal.state.type) {
+            mHal.state.type->dumpLOGV(buf);
+        }
     }
-
     ALOGV("%s allocation ptr=%p  mUsageFlags=0x04%x, mMipmapControl=0x%04x",
          prefix, mHal.drvState.lod[0].mallocPtr, mHal.state.usageFlags, mHal.state.mipmapControl);
 }
@@ -327,9 +328,7 @@
 void Allocation::serialize(Context *rsc, OStream *stream) const {
     // Need to identify ourselves
     stream->addU32((uint32_t)getClassId());
-
-    String8 name(getName());
-    stream->addString(&name);
+    stream->addString(getName());
 
     // First thing we need to serialize is the type object since it will be needed
     // to initialize the class
@@ -358,8 +357,7 @@
         return NULL;
     }
 
-    String8 name;
-    stream->loadString(&name);
+    const char *name = stream->loadString();
 
     Type *type = Type::createFromStream(rsc, stream);
     if (!type) {
@@ -382,8 +380,7 @@
         return NULL;
     }
 
-    alloc->setName(name.string(), name.size());
-
+    alloc->assignName(name);
     if (dataSize == type->getSizeBytes()) {
         uint32_t count = dataSize / type->getElementSizeBytes();
         // Read in all of our allocation data
diff --git a/rsElement.cpp b/rsElement.cpp
index 559d567..29725c6 100644
--- a/rsElement.cpp
+++ b/rsElement.cpp
@@ -44,7 +44,12 @@
 }
 
 void Element::clear() {
-    delete [] mFields;
+    if (mFields) {
+        for (size_t i = 0; i < mFieldCount; i++) {
+            delete[] mFields[i].name;
+        }
+        delete [] mFields;
+    }
     mFields = NULL;
     mFieldCount = 0;
     mHasReference = false;
@@ -87,7 +92,7 @@
     for (uint32_t ct = 0; ct < mFieldCount; ct++) {
         ALOGV("%s Element field index: %u ------------------", prefix, ct);
         ALOGV("%s name: %s, offsetBits: %u, arraySize: %u",
-             prefix, mFields[ct].name.string(), mFields[ct].offsetBits, mFields[ct].arraySize);
+             prefix, mFields[ct].name, mFields[ct].offsetBits, mFields[ct].arraySize);
         mFields[ct].e->dumpLOGV(prefix);
     }
 }
@@ -95,16 +100,14 @@
 void Element::serialize(Context *rsc, OStream *stream) const {
     // Need to identify ourselves
     stream->addU32((uint32_t)getClassId());
-
-    String8 name(getName());
-    stream->addString(&name);
+    stream->addString(getName());
 
     mComponent.serialize(stream);
 
     // Now serialize all the fields
     stream->addU32(mFieldCount);
     for (uint32_t ct = 0; ct < mFieldCount; ct++) {
-        stream->addString(&mFields[ct].name);
+        stream->addString(mFields[ct].name);
         stream->addU32(mFields[ct].arraySize);
         mFields[ct].e->serialize(rsc, stream);
     }
@@ -118,8 +121,7 @@
         return NULL;
     }
 
-    String8 name;
-    stream->loadString(&name);
+    const char *name = stream->loadString();
 
     Component component;
     component.loadFromStream(stream);
@@ -138,13 +140,9 @@
     size_t *subElemNamesLengths = new size_t[fieldCount];
     uint32_t *arraySizes = new uint32_t[fieldCount];
 
-    String8 elemName;
     for (uint32_t ct = 0; ct < fieldCount; ct ++) {
-        stream->loadString(&elemName);
-        subElemNamesLengths[ct] = elemName.length();
-        char *tmpName = new char[subElemNamesLengths[ct]];
-        memcpy(tmpName, elemName.string(), subElemNamesLengths[ct]);
-        subElemNames[ct] = tmpName;
+        subElemNames[ct] = stream->loadString();
+        subElemNamesLengths[ct] = strlen(subElemNames[ct]);
         arraySizes[ct] = stream->loadU32();
         subElems[ct] = Element::createFromStream(rsc, stream);
     }
@@ -155,6 +153,7 @@
         delete [] subElemNames[ct];
         subElems[ct]->decUserRef();
     }
+    delete[] name;
     delete[] subElems;
     delete[] subElemNames;
     delete[] subElemNamesLengths;
@@ -179,7 +178,7 @@
 
     uint32_t noPaddingFieldCount = 0;
     for (uint32_t ct = 0; ct < mFieldCount; ct ++) {
-        if (mFields[ct].name.string()[0] != '#') {
+        if (mFields[ct].name[0] != '#') {
             noPaddingFieldCount ++;
         }
     }
@@ -203,14 +202,14 @@
             mHasReference = true;
         }
 
-        if (mFields[ct].name.string()[0] == '#') {
+        if (mFields[ct].name[0] == '#') {
             continue;
         }
 
         mHal.state.fields[ctNoPadding] = mFields[ct].e.get();
         mHal.state.fieldArraySizes[ctNoPadding] = mFields[ct].arraySize;
-        mHal.state.fieldNames[ctNoPadding] = mFields[ct].name.string();
-        mHal.state.fieldNameLengths[ctNoPadding] = mFields[ct].name.length() + 1; // to include 0
+        mHal.state.fieldNames[ctNoPadding] = mFields[ct].name;
+        mHal.state.fieldNameLengths[ctNoPadding] = strlen(mFields[ct].name) + 1; // to include 0
         mHal.state.fieldOffsetBytes[ctNoPadding] = mFields[ct].offsetBits >> 3;
 
         ctNoPadding ++;
@@ -274,8 +273,8 @@
                 }
 
                 if ((ee->mFields[i].e.get() != ein[i]) ||
-                    (ee->mFields[i].name.length() != len) ||
-                    (ee->mFields[i].name != nin[i]) ||
+                    (strlen(ee->mFields[i].name) != len) ||
+                    strcmp(ee->mFields[i].name, nin[i]) ||
                     (ee->mFields[i].arraySize != asize)) {
                     match = false;
                     break;
@@ -307,7 +306,7 @@
         }
 
         e->mFields[ct].e.set(ein[ct]);
-        e->mFields[ct].name.setTo(nin[ct], len);
+        e->mFields[ct].name = rsuCopyString(nin[ct], len);
         e->mFields[ct].arraySize = asize;
     }
     e->compute();
diff --git a/rsElement.h b/rsElement.h
index 32cfda1..b97dfe5 100644
--- a/rsElement.h
+++ b/rsElement.h
@@ -83,7 +83,7 @@
 
     uint32_t getFieldCount() const {return mFieldCount;}
     const Element * getField(uint32_t idx) const {return mFields[idx].e.get();}
-    const char * getFieldName(uint32_t idx) const {return mFields[idx].name.string();}
+    const char * getFieldName(uint32_t idx) const {return mFields[idx].name;}
     uint32_t getFieldArraySize(uint32_t idx) const {return mFields[idx].arraySize;}
 
     const Component & getComponent() const {return mComponent;}
@@ -137,7 +137,7 @@
     void clear();
 
     typedef struct {
-        String8 name;
+        const char *name;
         ObjectBaseRef<const Element> e;
         uint32_t offsetBits;
         uint32_t offsetBitsUnpadded;
diff --git a/rsFileA3D.cpp b/rsFileA3D.cpp
index c79d008..3b963fe 100644
--- a/rsFileA3D.cpp
+++ b/rsFileA3D.cpp
@@ -73,7 +73,8 @@
     uint32_t numIndexEntries = headerStream->loadU32();
     for (uint32_t i = 0; i < numIndexEntries; i ++) {
         A3DIndexEntry *entry = new A3DIndexEntry();
-        headerStream->loadString(&entry->mObjectName);
+        entry->mObjectName = headerStream->loadString();
+
         //ALOGV("Header data, entry name = %s", entry->mObjectName.string());
         entry->mType = (RsA3DClassID)headerStream->loadU32();
         if (mUse64BitOffsets){
@@ -214,6 +215,10 @@
     return mIndex.size();
 }
 
+FileA3D::A3DIndexEntry::~A3DIndexEntry() {
+    delete[] mObjectName;
+}
+
 const FileA3D::A3DIndexEntry *FileA3D::getIndexEntry(size_t index) const {
     if (index < mIndex.size()) {
         return mIndex[index];
@@ -320,7 +325,7 @@
     uint32_t writeIndexSize = mWriteIndex.size();
     headerStream.addU32(writeIndexSize);
     for (uint32_t i = 0; i < writeIndexSize; i ++) {
-        headerStream.addString(&mWriteIndex[i]->mObjectName);
+        headerStream.addString(mWriteIndex[i]->mObjectName);
         headerStream.addU32((uint32_t)mWriteIndex[i]->mType);
         if (mUse64BitOffsets){
             headerStream.addOffset(mWriteIndex[i]->mOffset);
@@ -334,8 +339,7 @@
     }
 
     // Write our magic string so we know we are reading the right file
-    String8 magicString(A3D_MAGIC_KEY);
-    fwrite(magicString.string(), sizeof(char), magicString.size(), writeHandle);
+    fwrite(A3D_MAGIC_KEY, sizeof(char), strlen(A3D_MAGIC_KEY), writeHandle);
 
     // Store the size of the header to make it easier to parse when we read it
     uint64_t headerSize = headerStream.getPos();
@@ -369,7 +373,7 @@
         mWriteStream = new OStream(initialStreamSize, false);
     }
     A3DIndexEntry *indexEntry = new A3DIndexEntry();
-    indexEntry->mObjectName.setTo(obj->getName());
+    indexEntry->mObjectName = rsuCopyString(obj->getName());
     indexEntry->mType = obj->getClassId();
     indexEntry->mOffset = mWriteStream->getPos();
     indexEntry->mRsObj = obj;
@@ -420,7 +424,7 @@
     for (uint32_t i = 0; i < numFileEntries; i ++) {
         const FileA3D::A3DIndexEntry *entry = fa3d->getIndexEntry(i);
         fileEntries[i].classID = entry->getType();
-        fileEntries[i].objectName = entry->getObjectName().string();
+        fileEntries[i].objectName = rsuCopyString(entry->getObjectName());
     }
 }
 
diff --git a/rsFileA3D.h b/rsFileA3D.h
index 06b90d7..8bf36b9 100644
--- a/rsFileA3D.h
+++ b/rsFileA3D.h
@@ -19,7 +19,6 @@
 
 #include "rsMesh.h"
 
-#include <utils/String8.h>
 #include "rsStream.h"
 #include <stdio.h>
 
@@ -43,19 +42,21 @@
     bool mUse64BitOffsets;
 
     class A3DIndexEntry {
-        String8 mObjectName;
+        const char *mObjectName;
         RsA3DClassID mType;
         uint64_t mOffset;
         uint64_t mLength;
         ObjectBase *mRsObj;
     public:
         friend class FileA3D;
-        const String8 &getObjectName() const {
+        const char *getObjectName() const {
             return mObjectName;
         }
         RsA3DClassID getType() const {
             return mType;
         }
+
+        ~A3DIndexEntry();
     };
 
     bool load(FILE *f);
diff --git a/rsFont.cpp b/rsFont.cpp
index a483359..d302182 100644
--- a/rsFont.cpp
+++ b/rsFont.cpp
@@ -58,7 +58,7 @@
         return false;
     }
 
-    mFontName = name;
+    mFontName = rsuCopyString(name);
     mFontSize = fontSize;
     mDpi = dpi;
 
@@ -492,13 +492,13 @@
 #endif //ANDROID_RS_SERIALIZE
 
 void FontState::initRenderState() {
-    String8 shaderString("varying vec2 varTex0;\n");
-    shaderString.append("void main() {\n");
-    shaderString.append("  lowp vec4 col = UNI_Color;\n");
-    shaderString.append("  col.a = texture2D(UNI_Tex0, varTex0.xy).a;\n");
-    shaderString.append("  col.a = pow(col.a, UNI_Gamma);\n");
-    shaderString.append("  gl_FragColor = col;\n");
-    shaderString.append("}\n");
+    const char *shaderString = "varying vec2 varTex0;\n"
+                               "void main() {\n"
+                               "  lowp vec4 col = UNI_Color;\n"
+                               "  col.a = texture2D(UNI_Tex0, varTex0.xy).a;\n"
+                               "  col.a = pow(col.a, UNI_Gamma);\n"
+                               "  gl_FragColor = col;\n"
+                               "}\n";
 
     const char *textureNames[] = { "Tex0" };
     const size_t textureNamesLengths[] = { 4 };
@@ -524,7 +524,7 @@
     mFontShaderFConstant.set(Allocation::createAllocation(mRSC, inputType.get(),
                                                           RS_ALLOCATION_USAGE_SCRIPT |
                                                           RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS));
-    ProgramFragment *pf = new ProgramFragment(mRSC, shaderString.string(), shaderString.length(),
+    ProgramFragment *pf = new ProgramFragment(mRSC, shaderString, strlen(shaderString),
                                               textureNames, numTextures, textureNamesLengths,
                                               tmp, 4);
     mFontShaderF.set(pf);
@@ -757,11 +757,12 @@
     Font *currentFont = mRSC->getFont();
     if (!currentFont) {
         if (!mDefault.get()) {
-            String8 fontsDir("/fonts/Roboto-Regular.ttf");
-            String8 fullPath(getenv("ANDROID_ROOT"));
-            fullPath += fontsDir;
-
-            mDefault.set(Font::create(mRSC, fullPath.string(), 8, mRSC->getDPI()));
+            char fullPath[1024];
+            const char * root = getenv("ANDROID_ROOT");
+            rsAssert(strlen(root) < 256);
+            strcpy(fullPath, root);
+            strcat(fullPath, "/fonts/Roboto-Regular.ttf");
+            mDefault.set(Font::create(mRSC, fullPath, 8, mRSC->getDPI()));
         }
         currentFont = mDefault.get();
     }
diff --git a/rsFont.h b/rsFont.h
index f7ad3cd..7bac508 100644
--- a/rsFont.h
+++ b/rsFont.h
@@ -18,7 +18,6 @@
 #define ANDROID_RS_FONT_H
 
 #include "rsStream.h"
-#include <utils/String8.h>
 #include <utils/Vector.h>
 #include <utils/KeyedVector.h>
 
@@ -113,7 +112,7 @@
         int32_t mBitmapTop;
     };
 
-    String8 mFontName;
+    const char *mFontName;
     float mFontSize;
     uint32_t mDpi;
 
diff --git a/rsMesh.cpp b/rsMesh.cpp
index 651a8f3..8decfc5 100644
--- a/rsMesh.cpp
+++ b/rsMesh.cpp
@@ -81,9 +81,7 @@
 void Mesh::serialize(Context *rsc, OStream *stream) const {
     // Need to identify ourselves
     stream->addU32((uint32_t)getClassId());
-
-    String8 name(getName());
-    stream->addString(&name);
+    stream->addString(getName());
 
     // Store number of vertex streams
     stream->addU32(mHal.state.vertexBuffersCount);
@@ -113,8 +111,7 @@
         return NULL;
     }
 
-    String8 name;
-    stream->loadString(&name);
+    const char *name = stream->loadString();
 
     uint32_t vertexBuffersCount = stream->loadU32();
     ObjectBaseRef<Allocation> *vertexBuffers = NULL;
@@ -148,7 +145,7 @@
     }
 
     Mesh *mesh = new Mesh(rsc, vertexBuffersCount, primitivesCount);
-    mesh->setName(name.string(), name.size());
+    mesh->assignName(name);
     for (uint32_t vCount = 0; vCount < vertexBuffersCount; vCount ++) {
         mesh->setVertexBuffer(vertexBuffers[vCount].get(), vCount);
     }
diff --git a/rsObjectBase.h b/rsObjectBase.h
index 12c89a3..85f8fd8 100644
--- a/rsObjectBase.h
+++ b/rsObjectBase.h
@@ -44,6 +44,7 @@
     const char * getName() const {
         return mName;
     }
+    void assignName(const char *s) {mName = s;}
     void setName(const char *);
     void setName(const char *, uint32_t len);
 
diff --git a/rsStream.cpp b/rsStream.cpp
index b9df0cc..a9587c1 100644
--- a/rsStream.cpp
+++ b/rsStream.cpp
@@ -43,10 +43,11 @@
     return loadU32();
 }
 
-void IStream::loadString(String8 *s) {
+const char * IStream::loadString() {
     uint32_t len = loadU32();
-    s->setTo((const char *)&mData[mPos], len);
+    const char *s = rsuCopyString((const char *)&mData[mPos], len);
     mPos += len;
+    return s;
 }
 
 // Output stream implementation
@@ -89,19 +90,20 @@
     }
 }
 
-void OStream::addString(String8 *s) {
-    uint32_t len = s->size();
+void OStream::addString(const char *s, size_t len) {
     addU32(len);
     if (mPos + len*sizeof(char) >= mLength) {
         growSize();
     }
     char *stringData = reinterpret_cast<char *>(&mData[mPos]);
-    for (uint32_t i = 0; i < len; i ++) {
-        stringData[i] = s->string()[i];
-    }
+    memcpy(stringData, s, len);
     mPos += len*sizeof(char);
 }
 
+void OStream::addString(const char *s) {
+    addString(s, strlen(s));
+}
+
 void OStream::growSize() {
     uint8_t *newData = (uint8_t*)malloc(mLength*2);
     memcpy(newData, mData, mLength*sizeof(uint8_t));
diff --git a/rsStream.h b/rsStream.h
index 8a192e6..d0ed62e 100644
--- a/rsStream.h
+++ b/rsStream.h
@@ -59,7 +59,7 @@
     }
     void loadByteArray(void *dest, size_t numBytes);
     uint64_t loadOffset();
-    void loadString(String8 *s);
+    const char * loadString();
     uint64_t getPos() const {
         return mPos;
     }
@@ -132,7 +132,8 @@
     }
     void addByteArray(const void *src, size_t numBytes);
     void addOffset(uint64_t v);
-    void addString(String8 *s);
+    void addString(const char *name);
+    void addString(const char *name, size_t len);
     uint64_t getPos() const {
         return mPos;
     }
diff --git a/rsType.cpp b/rsType.cpp
index 9719a04..2822d5b 100644
--- a/rsType.cpp
+++ b/rsType.cpp
@@ -188,9 +188,7 @@
 void Type::serialize(Context *rsc, OStream *stream) const {
     // Need to identify ourselves
     stream->addU32((uint32_t)getClassId());
-
-    String8 name(getName());
-    stream->addString(&name);
+    stream->addString(getName());
 
     mElement->serialize(rsc, stream);
 
@@ -210,8 +208,7 @@
         return NULL;
     }
 
-    String8 name;
-    stream->loadString(&name);
+    const char *name = stream->loadString();
 
     Element *elem = Element::createFromStream(rsc, stream);
     if (!elem) {
@@ -225,6 +222,8 @@
     uint8_t faces = stream->loadU8();
     Type *type = Type::getType(rsc, elem, x, y, z, lod != 0, faces !=0, 0);
     elem->decUserRef();
+
+    delete [] name;
     return type;
 }