diff --git a/libs/rs/rs.spec b/libs/rs/rs.spec
index 1da00a5..29de5f0 100644
--- a/libs/rs/rs.spec
+++ b/libs/rs/rs.spec
@@ -45,16 +45,14 @@
     direct
     param void *data
     param size_t *receiveLen
-    param uint32_t *subID
-    param bool wait
+    param uint32_t *usrID
     ret RsMessageToClientType
 }
 
 ContextPeekMessage {
     direct
     param size_t *receiveLen
-    param uint32_t *subID
-    param bool wait
+    param uint32_t *usrID
     ret RsMessageToClientType
 }
 
@@ -106,7 +104,7 @@
 
 
 ContextFinish {
-	handcodeApi
+	sync
 	}
 
 ContextBindRootScript {
diff --git a/libs/rs/rsContext.cpp b/libs/rs/rsContext.cpp
index 98adabc..6027946 100644
--- a/libs/rs/rsContext.cpp
+++ b/libs/rs/rsContext.cpp
@@ -344,6 +344,8 @@
 bool Context::initContext(Device *dev, const RsSurfaceConfig *sc) {
     pthread_mutex_lock(&gInitMutex);
 
+    mIO.init();
+
     dev->addContext(this);
     mDev = dev;
     if (sc) {
@@ -393,7 +395,7 @@
 Context::~Context() {
     LOGV("Context::~Context");
 
-    mIO.mToCore.flush();
+    mIO.coreFlush();
     rsAssert(mExit);
     mExit = true;
     mPaused = false;
@@ -505,69 +507,18 @@
     }
 }
 
-RsMessageToClientType Context::peekMessageToClient(size_t *receiveLen, uint32_t *subID, bool wait) {
-    *receiveLen = 0;
-    if (!wait && mIO.mToClient.isEmpty()) {
-        return RS_MESSAGE_TO_CLIENT_NONE;
-    }
-
-    uint32_t bytesData = 0;
-    uint32_t commandID = 0;
-    const uint32_t *d = (const uint32_t *)mIO.mToClient.get(&commandID, &bytesData);
-    *receiveLen = bytesData - sizeof(uint32_t);
-    if (bytesData) {
-        *subID = d[0];
-    }
-    return (RsMessageToClientType)commandID;
+RsMessageToClientType Context::peekMessageToClient(size_t *receiveLen, uint32_t *subID) {
+    return (RsMessageToClientType)mIO.getClientHeader(receiveLen, subID);
 }
 
-RsMessageToClientType Context::getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen, bool wait) {
-    //LOGE("getMessageToClient %i %i", bufferLen, wait);
-    *receiveLen = 0;
-    if (!wait && mIO.mToClient.isEmpty()) {
-        return RS_MESSAGE_TO_CLIENT_NONE;
-    }
-
-    //LOGE("getMessageToClient 2 con=%p", this);
-    uint32_t bytesData = 0;
-    uint32_t commandID = 0;
-    const uint32_t *d = (const uint32_t *)mIO.mToClient.get(&commandID, &bytesData);
-    //LOGE("getMessageToClient 3    %i  %i", commandID, bytesData);
-
-    *receiveLen = bytesData - sizeof(uint32_t);
-    *subID = d[0];
-
-    //LOGE("getMessageToClient  %i %i", commandID, *subID);
-    if (bufferLen >= (*receiveLen)) {
-        memcpy(data, d+1, *receiveLen);
-        mIO.mToClient.next();
-        return (RsMessageToClientType)commandID;
-    }
-    return RS_MESSAGE_TO_CLIENT_RESIZE;
+RsMessageToClientType Context::getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen) {
+    return (RsMessageToClientType)mIO.getClientPayload(data, receiveLen, subID, bufferLen);
 }
 
 bool Context::sendMessageToClient(const void *data, RsMessageToClientType cmdID,
                                   uint32_t subID, size_t len, bool waitForSpace) const {
-    //LOGE("sendMessageToClient %i %i %i %i", cmdID, subID, len, waitForSpace);
-    if (cmdID == 0) {
-        LOGE("Attempting to send invalid command 0 to client.");
-        return false;
-    }
-    if (!waitForSpace) {
-        if (!mIO.mToClient.makeSpaceNonBlocking(len + 12)) {
-            // Not enough room, and not waiting.
-            return false;
-        }
-    }
-    //LOGE("sendMessageToClient 2");
-    uint32_t *p = (uint32_t *)mIO.mToClient.reserve(len + sizeof(subID));
-    p[0] = subID;
-    if (len > 0) {
-        memcpy(p+1, data, len);
-    }
-    mIO.mToClient.commit(cmdID, len + sizeof(subID));
-    //LOGE("sendMessageToClient 3");
-    return true;
+
+    return mIO.sendToClient(cmdID, subID, data, len, waitForSpace);
 }
 
 void Context::initToClient() {
@@ -577,7 +528,7 @@
 }
 
 void Context::deinitToClient() {
-    mIO.mToClient.shutdown();
+    mIO.clientShutdown();
 }
 
 void Context::setError(RsError e, const char *msg) const {
@@ -706,16 +657,16 @@
 
 RsMessageToClientType rsi_ContextPeekMessage(Context *rsc,
                                            size_t * receiveLen, size_t receiveLen_length,
-                                           uint32_t * subID, size_t subID_length, bool wait) {
-    return rsc->peekMessageToClient(receiveLen, subID, wait);
+                                           uint32_t * subID, size_t subID_length) {
+    return rsc->peekMessageToClient(receiveLen, subID);
 }
 
 RsMessageToClientType rsi_ContextGetMessage(Context *rsc, void * data, size_t data_length,
                                           size_t * receiveLen, size_t receiveLen_length,
-                                          uint32_t * subID, size_t subID_length, bool wait) {
+                                          uint32_t * subID, size_t subID_length) {
     rsAssert(subID_length == sizeof(uint32_t));
     rsAssert(receiveLen_length == sizeof(size_t));
-    return rsc->getMessageToClient(data, receiveLen, subID, data_length, wait);
+    return rsc->getMessageToClient(data, receiveLen, subID, data_length);
 }
 
 void rsi_ContextInitToClient(Context *rsc) {
diff --git a/libs/rs/rsContext.h b/libs/rs/rsContext.h
index 1407b7e..6336210 100644
--- a/libs/rs/rsContext.h
+++ b/libs/rs/rsContext.h
@@ -143,8 +143,8 @@
     void assignName(ObjectBase *obj, const char *name, uint32_t len);
     void removeName(ObjectBase *obj);
 
-    RsMessageToClientType peekMessageToClient(size_t *receiveLen, uint32_t *subID, bool wait);
-    RsMessageToClientType getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen, bool wait);
+    RsMessageToClientType peekMessageToClient(size_t *receiveLen, uint32_t *subID);
+    RsMessageToClientType getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen);
     bool sendMessageToClient(const void *data, RsMessageToClientType cmdID, uint32_t subID, size_t len, bool waitForSpace) const;
     uint32_t runScript(Script *s);
 
diff --git a/libs/rs/rsFifoSocket.cpp b/libs/rs/rsFifoSocket.cpp
index 1ce57b9..848bba5 100644
--- a/libs/rs/rsFifoSocket.cpp
+++ b/libs/rs/rsFifoSocket.cpp
@@ -45,23 +45,34 @@
 }
 
 void FifoSocket::writeAsync(const void *data, size_t bytes) {
-    size_t ret = ::write(sv[0], data, bytes);
+    if (bytes == 0) {
+        return;
+    }
+    //LOGE("writeAsync %p %i", data, bytes);
+    size_t ret = ::send(sv[0], data, bytes, 0);
+    //LOGE("writeAsync ret %i", ret);
     rsAssert(ret == bytes);
 }
 
 void FifoSocket::writeWaitReturn(void *retData, size_t retBytes) {
-    size_t ret = ::read(sv[1], retData, retBytes);
+    //LOGE("writeWaitReturn %p %i", retData, retBytes);
+    size_t ret = ::recv(sv[0], retData, retBytes, 0);
+    //LOGE("writeWaitReturn %i", ret);
     rsAssert(ret == retBytes);
 }
 
 size_t FifoSocket::read(void *data, size_t bytes) {
-    size_t ret = ::read(sv[0], data, bytes);
+    //LOGE("read %p %i", data, bytes);
+    size_t ret = ::recv(sv[1], data, bytes, 0);
     rsAssert(ret == bytes);
+    //LOGE("read ret %i", ret);
     return ret;
 }
 
 void FifoSocket::readReturn(const void *data, size_t bytes) {
-    size_t ret = ::write(sv[1], data, bytes);
+    LOGE("readReturn %p %i", data, bytes);
+    size_t ret = ::send(sv[1], data, bytes, 0);
+    LOGE("readReturn %i", ret);
     rsAssert(ret == bytes);
 }
 
diff --git a/libs/rs/rsHandcode.h b/libs/rs/rsHandcode.h
deleted file mode 100644
index e6b722c..0000000
--- a/libs/rs/rsHandcode.h
+++ /dev/null
@@ -1,9 +0,0 @@
-
-#define DATA_SYNC_SIZE 1024
-
-static inline void rsHCAPI_ContextFinish (RsContext rsc) {
-    ThreadIO *io = &((Context *)rsc)->mIO;
-    uint32_t size = sizeof(RS_CMD_ContextFinish);
-    io->mToCore.commitSync(RS_CMD_ID_ContextFinish, size);
-}
-
diff --git a/libs/rs/rsThreadIO.cpp b/libs/rs/rsThreadIO.cpp
index 6e959a7..4429556 100644
--- a/libs/rs/rsThreadIO.cpp
+++ b/libs/rs/rsThreadIO.cpp
@@ -23,16 +23,96 @@
 
 ThreadIO::ThreadIO() {
     mToCore.init(16 * 1024);
-    mToClient.init(1024);
 }
 
 ThreadIO::~ThreadIO() {
 }
 
-void ThreadIO::shutdown() {
-    mToCore.shutdown();
+void ThreadIO::init(bool useSocket) {
+    mUsingSocket = useSocket;
+
+    if (mUsingSocket) {
+        mToClientSocket.init();
+        mToCoreSocket.init();
+    } else {
+        mToClient.init(1024);
+    }
 }
 
+void ThreadIO::shutdown() {
+    //LOGE("shutdown 1");
+    mToCore.shutdown();
+    //LOGE("shutdown 2");
+}
+
+void ThreadIO::coreFlush() {
+    //LOGE("coreFlush 1");
+    if (mUsingSocket) {
+    } else {
+        mToCore.flush();
+    }
+    //LOGE("coreFlush 2");
+}
+
+void * ThreadIO::coreHeader(uint32_t cmdID, size_t dataLen) {
+    //LOGE("coreHeader %i %i", cmdID, dataLen);
+    if (mUsingSocket) {
+        CoreCmdHeader hdr;
+        hdr.bytes = dataLen;
+        hdr.cmdID = cmdID;
+        mToCoreSocket.writeAsync(&hdr, sizeof(hdr));
+    } else {
+        mCoreCommandSize = dataLen;
+        mCoreCommandID = cmdID;
+        mCoreDataPtr = (uint8_t *)mToCore.reserve(dataLen);
+        mCoreDataBasePtr = mCoreDataPtr;
+    }
+    //LOGE("coreHeader ret %p", mCoreDataPtr);
+    return mCoreDataPtr;
+}
+
+void ThreadIO::coreData(const void *data, size_t dataLen) {
+    //LOGE("coreData %p %i", data, dataLen);
+    mToCoreSocket.writeAsync(data, dataLen);
+    //LOGE("coreData ret %p", mCoreDataPtr);
+}
+
+void ThreadIO::coreCommit() {
+    //LOGE("coreCommit %p %p %i", mCoreDataPtr, mCoreDataBasePtr, mCoreCommandSize);
+    if (mUsingSocket) {
+    } else {
+        rsAssert((size_t)(mCoreDataPtr - mCoreDataBasePtr) <= mCoreCommandSize);
+        mToCore.commit(mCoreCommandID, mCoreCommandSize);
+    }
+    //LOGE("coreCommit ret");
+}
+
+void ThreadIO::coreCommitSync() {
+    //LOGE("coreCommitSync %p %p %i", mCoreDataPtr, mCoreDataBasePtr, mCoreCommandSize);
+    if (mUsingSocket) {
+    } else {
+        rsAssert((size_t)(mCoreDataPtr - mCoreDataBasePtr) <= mCoreCommandSize);
+        mToCore.commitSync(mCoreCommandID, mCoreCommandSize);
+    }
+    //LOGE("coreCommitSync ret");
+}
+
+void ThreadIO::clientShutdown() {
+    //LOGE("coreShutdown 1");
+    mToClient.shutdown();
+    //LOGE("coreShutdown 2");
+}
+
+void ThreadIO::coreSetReturn(const void *data, size_t dataLen) {
+    rsAssert(dataLen <= sizeof(mToCoreRet));
+    memcpy(&mToCoreRet, data, dataLen);
+}
+
+void ThreadIO::coreGetReturn(void *data, size_t dataLen) {
+    memcpy(data, &mToCoreRet, dataLen);
+}
+
+
 bool ThreadIO::playCoreCommands(Context *con, bool waitForCommand) {
     bool ret = false;
     while (!mToCore.isEmpty() || waitForCommand) {
@@ -64,4 +144,82 @@
     return ret;
 }
 
+RsMessageToClientType ThreadIO::getClientHeader(size_t *receiveLen, uint32_t *usrID) {
+    if (mUsingSocket) {
+        mToClientSocket.read(&mLastClientHeader, sizeof(mLastClientHeader));
+    } else {
+        size_t bytesData = 0;
+        const uint32_t *d = (const uint32_t *)mToClient.get(&mLastClientHeader.cmdID, &bytesData);
+        if (bytesData >= sizeof(uint32_t)) {
+            mLastClientHeader.userID = d[0];
+            mLastClientHeader.bytes = bytesData - sizeof(uint32_t);
+        } else {
+            mLastClientHeader.userID = 0;
+            mLastClientHeader.bytes = 0;
+        }
+    }
+    receiveLen[0] = mLastClientHeader.bytes;
+    usrID[0] = mLastClientHeader.userID;
+    return (RsMessageToClientType)mLastClientHeader.cmdID;
+}
+
+RsMessageToClientType ThreadIO::getClientPayload(void *data, size_t *receiveLen,
+                                uint32_t *usrID, size_t bufferLen) {
+    receiveLen[0] = mLastClientHeader.bytes;
+    usrID[0] = mLastClientHeader.userID;
+    if (bufferLen < mLastClientHeader.bytes) {
+        return RS_MESSAGE_TO_CLIENT_RESIZE;
+    }
+    if (mUsingSocket) {
+        if (receiveLen[0]) {
+            mToClientSocket.read(data, receiveLen[0]);
+        }
+        return (RsMessageToClientType)mLastClientHeader.cmdID;
+    } else {
+        uint32_t bytesData = 0;
+        uint32_t commandID = 0;
+        const uint32_t *d = (const uint32_t *)mToClient.get(&commandID, &bytesData);
+        //LOGE("getMessageToClient 3    %i  %i", commandID, bytesData);
+        //LOGE("getMessageToClient  %i %i", commandID, *subID);
+        if (bufferLen >= receiveLen[0]) {
+            memcpy(data, d+1, receiveLen[0]);
+            mToClient.next();
+            return (RsMessageToClientType)commandID;
+        }
+    }
+    return RS_MESSAGE_TO_CLIENT_RESIZE;
+}
+
+bool ThreadIO::sendToClient(RsMessageToClientType cmdID, uint32_t usrID, const void *data,
+                            size_t dataLen, bool waitForSpace) {
+    ClientCmdHeader hdr;
+    hdr.bytes = dataLen;
+    hdr.cmdID = cmdID;
+    hdr.userID = usrID;
+    if (mUsingSocket) {
+        mToClientSocket.writeAsync(&hdr, sizeof(hdr));
+        if (dataLen) {
+            mToClientSocket.writeAsync(data, dataLen);
+        }
+        return true;
+    } else {
+        if (!waitForSpace) {
+            if (!mToClient.makeSpaceNonBlocking(dataLen + sizeof(hdr))) {
+                // Not enough room, and not waiting.
+                return false;
+            }
+        }
+
+        //LOGE("sendMessageToClient 2");
+        uint32_t *p = (uint32_t *)mToClient.reserve(dataLen + sizeof(usrID));
+        p[0] = usrID;
+        if (dataLen > 0) {
+            memcpy(p+1, data, dataLen);
+        }
+        mToClient.commit(cmdID, dataLen + sizeof(usrID));
+        //LOGE("sendMessageToClient 3");
+        return true;
+    }
+    return false;
+}
 
diff --git a/libs/rs/rsThreadIO.h b/libs/rs/rsThreadIO.h
index f9d0de7..cad7318 100644
--- a/libs/rs/rsThreadIO.h
+++ b/libs/rs/rsThreadIO.h
@@ -19,6 +19,7 @@
 
 #include "rsUtils.h"
 #include "rsLocklessFifo.h"
+#include "rsFifoSocket.h"
 
 // ---------------------------------------------------------------------------
 namespace android {
@@ -31,17 +32,58 @@
     ThreadIO();
     ~ThreadIO();
 
+    void init(bool useSocket = false);
     void shutdown();
 
     // Plays back commands from the client.
     // Returns true if any commands were processed.
     bool playCoreCommands(Context *con, bool waitForCommand);
 
+    //LocklessCommandFifo mToCore;
 
-    LocklessCommandFifo mToCore;
+
+
+    void coreFlush();
+    void * coreHeader(uint32_t, size_t dataLen);
+    void coreData(const void *data, size_t dataLen);
+    void coreCommit();
+    void coreCommitSync();
+    void coreSetReturn(const void *data, size_t dataLen);
+    void coreGetReturn(void *data, size_t dataLen);
+
+
+    RsMessageToClientType getClientHeader(size_t *receiveLen, uint32_t *usrID);
+    RsMessageToClientType getClientPayload(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen);
+    bool sendToClient(RsMessageToClientType cmdID, uint32_t usrID, const void *data, size_t dataLen, bool waitForSpace);
+    void clientShutdown();
+
+
+protected:
+    typedef struct CoreCmdHeaderRec {
+        uint32_t cmdID;
+        uint32_t bytes;
+    } CoreCmdHeader;
+    typedef struct ClientCmdHeaderRec {
+        uint32_t cmdID;
+        uint32_t bytes;
+        uint32_t userID;
+    } ClientCmdHeader;
+    ClientCmdHeader mLastClientHeader;
+
+    size_t mCoreCommandSize;
+    uint32_t mCoreCommandID;
+    uint8_t * mCoreDataPtr;
+    uint8_t * mCoreDataBasePtr;
+
+    bool mUsingSocket;
     LocklessCommandFifo mToClient;
+    LocklessCommandFifo mToCore;
+
+    FifoSocket mToClientSocket;
+    FifoSocket mToCoreSocket;
 
     intptr_t mToCoreRet;
+
 };
 
 
diff --git a/libs/rs/rsg_generator.c b/libs/rs/rsg_generator.c
index d550712..b3f6c55 100644
--- a/libs/rs/rsg_generator.c
+++ b/libs/rs/rsg_generator.c
@@ -193,7 +193,6 @@
     fprintf(f, "\n");
     fprintf(f, "using namespace android;\n");
     fprintf(f, "using namespace android::renderscript;\n");
-    fprintf(f, "#include \"rsHandcode.h\"\n");
     fprintf(f, "\n");
 
     printFuncPointers(f, 0);
@@ -206,18 +205,14 @@
         fprintf(f, "static ");
         printFuncDecl(f, api, "LF_", 0, 0);
         fprintf(f, "\n{\n");
-        if (api->handcodeApi || api->direct) {
-            if (api->handcodeApi) {
-                fprintf(f, "    rsHCAPI_%s(rsc", api->name);
-            } else {
-                fprintf(f, "    ");
-                if (api->ret.typeName[0]) {
-                    fprintf(f, "return ");
-                }
-                fprintf(f, "rsi_%s(", api->name);
-                if (!api->nocontext) {
-                    fprintf(f, "(Context *)rsc");
-                }
+        if (api->direct) {
+            fprintf(f, "    ");
+            if (api->ret.typeName[0]) {
+                fprintf(f, "return ");
+            }
+            fprintf(f, "rsi_%s(", api->name);
+            if (!api->nocontext) {
+                fprintf(f, "(Context *)rsc");
             }
             for (ct2=0; ct2 < api->paramCount; ct2++) {
                 const VarType *vt = &api->params[ct2];
@@ -244,13 +239,13 @@
             if (hasInlineDataPointers(api)) {
                 fprintf(f, "    RS_CMD_%s *cmd = NULL;\n", api->name);
                 fprintf(f, "    if (dataSize < 1024) {;\n");
-                fprintf(f, "        cmd = static_cast<RS_CMD_%s *>(io->mToCore.reserve(dataSize + size));\n", api->name);
+                fprintf(f, "        cmd = static_cast<RS_CMD_%s *>(io->coreHeader(RS_CMD_ID_%s, dataSize + size));\n", api->name, api->name);
                 fprintf(f, "    } else {\n");
-                fprintf(f, "        cmd = static_cast<RS_CMD_%s *>(io->mToCore.reserve(size));\n", api->name);
+                fprintf(f, "        cmd = static_cast<RS_CMD_%s *>(io->coreHeader(RS_CMD_ID_%s, size));\n", api->name, api->name);
                 fprintf(f, "    }\n");
                 fprintf(f, "    uint8_t *payload = (uint8_t *)&cmd[1];\n");
             } else {
-                fprintf(f, "    RS_CMD_%s *cmd = static_cast<RS_CMD_%s *>(io->mToCore.reserve(size));\n", api->name, api->name);
+                fprintf(f, "    RS_CMD_%s *cmd = static_cast<RS_CMD_%s *>(io->coreHeader(RS_CMD_ID_%s, size));\n", api->name, api->name, api->name);
             }
 
             for (ct2=0; ct2 < api->paramCount; ct2++) {
@@ -271,28 +266,30 @@
                     fprintf(f, "    cmd->%s = %s;\n", vt->name, vt->name);
                 }
             }
-            if (api->ret.typeName[0]) {
+            if (api->ret.typeName[0] || api->sync) {
                 needFlush = 1;
             }
 
             if (hasInlineDataPointers(api)) {
                 fprintf(f, "    if (dataSize < 1024) {\n");
-                fprintf(f, "        io->mToCore.commit(RS_CMD_ID_%s, size + dataSize);\n", api->name);
+                fprintf(f, "        io->coreCommit();\n");
                 fprintf(f, "    } else {\n");
-                fprintf(f, "        io->mToCore.commitSync(RS_CMD_ID_%s, size);\n", api->name);
+                fprintf(f, "        io->coreCommitSync();\n");
                 fprintf(f, "    }\n");
             } else {
-                fprintf(f, "    io->mToCore.commit");
+                fprintf(f, "    io->coreCommit");
                 if (needFlush) {
                     fprintf(f, "Sync");
                 }
-                fprintf(f, "(RS_CMD_ID_%s, size);\n", api->name);
+                fprintf(f, "();\n");
             }
 
             if (api->ret.typeName[0]) {
-                fprintf(f, "    return reinterpret_cast<");
+                fprintf(f, "\n    ");
                 printVarType(f, &api->ret);
-                fprintf(f, ">(io->mToCoreRet);\n");
+                fprintf(f, " ret;\n");
+                fprintf(f, "    io->coreGetReturn(&ret, sizeof(ret));\n");
+                fprintf(f, "    return ret;\n");
             }
         }
         fprintf(f, "};\n\n");
@@ -306,86 +303,73 @@
         fprintf(f, "    const uint32_t cmdSize = sizeof(cmd);\n");
         fprintf(f, "    const uint32_t cmdID = RS_CMD_ID_%s;\n", api->name);
         fprintf(f, "    f->writeAsync(&cmdID, sizeof(cmdID));\n");
-
-        if (api->handcodeApi) {
-            fprintf(f, "    rsHCAPI_%s(rsc", api->name);
-            for (ct2=0; ct2 < api->paramCount; ct2++) {
-                const VarType *vt = &api->params[ct2];
-                if (ct2 > 0 || !api->nocontext) {
-                    fprintf(f, ", ");
-                }
-                fprintf(f, "%s", vt->name);
-            }
-            fprintf(f, ");\n");
-        } else {
-            fprintf(f, "    intptr_t offset = cmdSize;\n");
-            fprintf(f, "    uint32_t dataSize = 0;\n");
-            for (ct2=0; ct2 < api->paramCount; ct2++) {
-                const VarType *vt = &api->params[ct2];
-                if (vt->isConst && vt->ptrLevel) {
-                    switch(vt->ptrLevel) {
-                    case 1:
-                        fprintf(f, "    dataSize += %s_length;\n", vt->name);
-                        break;
-                    case 2:
-                        fprintf(f, "    for (size_t ct = 0; ct < (%s_length_length / sizeof(%s_length)); ct++) {\n", vt->name, vt->name);
-                        fprintf(f, "        dataSize += %s_length[ct];\n", vt->name);
-                        fprintf(f, "    }\n");
-                        break;
-                    default:
-                        printf("pointer level not handled!!");
-                    }
-                }
-            }
-            fprintf(f, "\n");
-
-            for (ct2=0; ct2 < api->paramCount; ct2++) {
-                const VarType *vt = &api->params[ct2];
+        fprintf(f, "    intptr_t offset = cmdSize;\n");
+        fprintf(f, "    uint32_t dataSize = 0;\n");
+        for (ct2=0; ct2 < api->paramCount; ct2++) {
+            const VarType *vt = &api->params[ct2];
+            if (vt->isConst && vt->ptrLevel) {
                 switch(vt->ptrLevel) {
-                case 0:
-                    fprintf(f, "    cmd.%s = %s;\n", vt->name, vt->name);
-                    break;
                 case 1:
-                    fprintf(f, "    cmd.%s = (", vt->name);
-                    printVarType(f, vt);
-                    fprintf(f, ")offset;\n");
-                    fprintf(f, "    offset += %s_length;\n", vt->name);
+                    fprintf(f, "    dataSize += %s_length;\n", vt->name);
                     break;
                 case 2:
-                    fprintf(f, "    cmd.%s = (", vt->name);
-                    printVarType(f, vt);
-                    fprintf(f, ")offset;\n");
                     fprintf(f, "    for (size_t ct = 0; ct < (%s_length_length / sizeof(%s_length)); ct++) {\n", vt->name, vt->name);
-                    fprintf(f, "        offset += %s_length[ct];\n", vt->name);
+                    fprintf(f, "        dataSize += %s_length[ct];\n", vt->name);
                     fprintf(f, "    }\n");
                     break;
                 default:
                     printf("pointer level not handled!!");
                 }
             }
-            fprintf(f, "\n");
+        }
+        fprintf(f, "\n");
 
-            fprintf(f, "    f->writeAsync(&cmd, cmdSize);\n");
-            for (ct2=0; ct2 < api->paramCount; ct2++) {
-                const VarType *vt = &api->params[ct2];
-                if (vt->ptrLevel == 1) {
-                    fprintf(f, "    f->writeAsync(%s, %s_length);\n", vt->name, vt->name);
-                }
-                if (vt->ptrLevel == 2) {
-                    fprintf(f, "    for (size_t ct = 0; ct < (%s_length_length / sizeof(%s_length)); ct++) {\n", vt->name, vt->name);
-                    fprintf(f, "        f->writeAsync(%s, %s_length[ct]);\n", vt->name, vt->name);
-                    fprintf(f, "        offset += %s_length[ct];\n", vt->name);
-                    fprintf(f, "    }\n");
-                }
+        for (ct2=0; ct2 < api->paramCount; ct2++) {
+            const VarType *vt = &api->params[ct2];
+            switch(vt->ptrLevel) {
+            case 0:
+                fprintf(f, "    cmd.%s = %s;\n", vt->name, vt->name);
+                break;
+            case 1:
+                fprintf(f, "    cmd.%s = (", vt->name);
+                printVarType(f, vt);
+                fprintf(f, ")offset;\n");
+                fprintf(f, "    offset += %s_length;\n", vt->name);
+                break;
+            case 2:
+                fprintf(f, "    cmd.%s = (", vt->name);
+                printVarType(f, vt);
+                fprintf(f, ")offset;\n");
+                fprintf(f, "    for (size_t ct = 0; ct < (%s_length_length / sizeof(%s_length)); ct++) {\n", vt->name, vt->name);
+                fprintf(f, "        offset += %s_length[ct];\n", vt->name);
+                fprintf(f, "    }\n");
+                break;
+            default:
+                fprintf(stderr, "pointer level not handled!!");
             }
+        }
+        fprintf(f, "\n");
 
-            if (api->ret.typeName[0]) {
-                fprintf(f, "    ");
-                printVarType(f, &api->ret);
-                fprintf(f, " retValue;\n");
-                fprintf(f, "    f->writeWaitReturn(&retValue, sizeof(retValue));\n");
-                fprintf(f, "    return retValue;\n");
+        fprintf(f, "    f->writeAsync(&cmd, cmdSize);\n");
+        for (ct2=0; ct2 < api->paramCount; ct2++) {
+            const VarType *vt = &api->params[ct2];
+            if (vt->ptrLevel == 1) {
+                fprintf(f, "    f->writeAsync(%s, %s_length);\n", vt->name, vt->name);
             }
+            if (vt->ptrLevel == 2) {
+                fprintf(f, "    for (size_t ct = 0; ct < (%s_length_length / sizeof(%s_length)); ct++) {\n", vt->name, vt->name);
+                fprintf(f, "        f->writeAsync(%s, %s_length[ct]);\n", vt->name, vt->name);
+                fprintf(f, "        offset += %s_length[ct];\n", vt->name);
+                fprintf(f, "    }\n");
+            }
+        }
+
+        if (api->ret.typeName[0]) {
+            fprintf(f, "    ");
+            printVarType(f, &api->ret);
+            fprintf(f, " retValue;\n");
+            fprintf(f, "    f->writeWaitReturn(&retValue, sizeof(retValue));\n");
+            fprintf(f, "    return retValue;\n");
         }
         fprintf(f, "}\n\n");
     }
@@ -446,7 +430,6 @@
     fprintf(f, "\n");
     fprintf(f, "namespace android {\n");
     fprintf(f, "namespace renderscript {\n");
-    fprintf(f, "#include \"rsHandcode.h\"\n");
     fprintf(f, "\n");
 
     for (ct=0; ct < apiCount; ct++) {
@@ -463,7 +446,9 @@
 
         fprintf(f, "    ");
         if (api->ret.typeName[0]) {
-            fprintf(f, "con->mIO.mToCoreRet = (intptr_t)");
+            fprintf(f, "\n    ");
+            printVarType(f, &api->ret);
+            fprintf(f, " ret = ");
         }
         fprintf(f, "rsi_%s(con", api->name);
         for (ct2=0; ct2 < api->paramCount; ct2++) {
@@ -472,6 +457,10 @@
         }
         fprintf(f, ");\n");
 
+        if (api->ret.typeName[0]) {
+            fprintf(f, "    con->mIO.coreSetReturn(&ret, sizeof(ret));\n");
+        }
+
         fprintf(f, "};\n\n");
     }