diff --git a/Android.mk b/Android.mk
index d9af8cc..36f9730 100644
--- a/Android.mk
+++ b/Android.mk
@@ -141,6 +141,7 @@
 	rsAnimation.cpp \
 	rsComponent.cpp \
 	rsContext.cpp \
+	rsClosure.cpp \
 	rsCppUtils.cpp \
 	rsDevice.cpp \
 	rsElement.cpp \
@@ -167,6 +168,7 @@
 	rsScriptC_Lib.cpp \
 	rsScriptC_LibGL.cpp \
 	rsScriptGroup.cpp \
+	rsScriptGroup2.cpp \
 	rsScriptIntrinsic.cpp \
 	rsSignal.cpp \
 	rsStream.cpp \
@@ -245,6 +247,7 @@
 	rsAnimation.cpp \
 	rsComponent.cpp \
 	rsContext.cpp \
+	rsClosure.cpp \
 	rsDevice.cpp \
 	rsElement.cpp \
 	rsFBOCache.cpp \
@@ -269,6 +272,7 @@
 	rsScriptC_Lib.cpp \
 	rsScriptC_LibGL.cpp \
 	rsScriptGroup.cpp \
+	rsScriptGroup2.cpp \
 	rsScriptIntrinsic.cpp \
 	rsSignal.cpp \
 	rsStream.cpp \
diff --git a/cpp/rsDispatch.h b/cpp/rsDispatch.h
index 659591b..53d72d4 100644
--- a/cpp/rsDispatch.h
+++ b/cpp/rsDispatch.h
@@ -28,7 +28,9 @@
 typedef void (*DeviceSetConfigFnPtr) (RsDevice dev, RsDeviceParam p, int32_t value);
 typedef RsContext (*ContextCreateFnPtr)(RsDevice vdev, uint32_t version, uint32_t sdkVersion, RsContextType ct, uint32_t flags);
 typedef void (*GetNameFnPtr)(RsContext, void * obj, const char **name);
-
+typedef RsClosure (*ClosureCreateFnPtr)(RsContext, RsScriptKernelID, RsAllocation, RsScriptFieldID*, size_t, uintptr_t*, size_t, size_t*, size_t, RsClosure*, size_t, RsScriptFieldID*, size_t);
+typedef void (*ClosureSetArgFnPtr)(RsContext, RsClosure, uint32_t, uintptr_t, size_t);
+typedef void (*ClosureSetGlobalFnPtr)(RsContext, RsClosure, RsScriptFieldID, uintptr_t, size_t);
 typedef void (*ContextDestroyFnPtr) (RsContext);
 typedef RsMessageToClientType (*ContextGetMessageFnPtr) (RsContext, void*, size_t, size_t*, size_t, uint32_t*, size_t);
 typedef RsMessageToClientType (*ContextPeekMessageFnPtr) (RsContext, size_t*, size_t, uint32_t*, size_t);
@@ -80,6 +82,7 @@
 typedef RsScriptKernelID (*ScriptKernelIDCreateFnPtr) (RsContext, RsScript, int, int);
 typedef RsScriptFieldID (*ScriptFieldIDCreateFnPtr) (RsContext, RsScript, int);
 typedef RsScriptGroup (*ScriptGroupCreateFnPtr) (RsContext, RsScriptKernelID*, size_t, RsScriptKernelID*, size_t, RsScriptKernelID*, size_t, RsScriptFieldID*, size_t, const RsType*, size_t);
+typedef RsScriptGroup2 (*ScriptGroup2CreateFnPtr)(RsContext, RsClosure*, size_t);
 typedef void (*ScriptGroupSetOutputFnPtr) (RsContext, RsScriptGroup, RsScriptKernelID, RsAllocation);
 typedef void (*ScriptGroupSetInputFnPtr) (RsContext, RsScriptGroup, RsScriptKernelID, RsAllocation);
 typedef void (*ScriptGroupExecuteFnPtr) (RsContext, RsScriptGroup);
@@ -113,6 +116,9 @@
     AllocationCubeCreateFromBitmapFnPtr AllocationCubeCreateFromBitmap;
     AllocationGetSurfaceFnPtr AllocationGetSurface;
     AllocationSetSurfaceFnPtr AllocationSetSurface;
+    ClosureCreateFnPtr ClosureCreate;
+    ClosureSetArgFnPtr ClosureSetArg;
+    ClosureSetGlobalFnPtr ClosureSetGlobal;
     ContextFinishFnPtr ContextFinish;
     ContextDumpFnPtr ContextDump;
     ContextSetPriorityFnPtr ContextSetPriority;
@@ -152,6 +158,7 @@
     ScriptKernelIDCreateFnPtr ScriptKernelIDCreate;
     ScriptFieldIDCreateFnPtr ScriptFieldIDCreate;
     ScriptGroupCreateFnPtr ScriptGroupCreate;
+    ScriptGroup2CreateFnPtr ScriptGroup2Create;
     ScriptGroupSetOutputFnPtr ScriptGroupSetOutput;
     ScriptGroupSetInputFnPtr ScriptGroupSetInput;
     ScriptGroupExecuteFnPtr ScriptGroupExecute;
diff --git a/cpu_ref/Android.mk b/cpu_ref/Android.mk
index 5de964f..27243f9 100644
--- a/cpu_ref/Android.mk
+++ b/cpu_ref/Android.mk
@@ -29,6 +29,7 @@
 	rsCpuRuntimeMath.cpp \
 	rsCpuRuntimeStubs.cpp \
 	rsCpuScriptGroup.cpp \
+	rsCpuScriptGroup2.cpp \
 	rsCpuIntrinsic.cpp \
 	rsCpuIntrinsic3DLUT.cpp \
 	rsCpuIntrinsicBlend.cpp \
diff --git a/cpu_ref/rsCpuCore.cpp b/cpu_ref/rsCpuCore.cpp
index 47bc1c0..84c2416 100644
--- a/cpu_ref/rsCpuCore.cpp
+++ b/cpu_ref/rsCpuCore.cpp
@@ -17,6 +17,7 @@
 #include "rsCpuCore.h"
 #include "rsCpuScript.h"
 #include "rsCpuScriptGroup.h"
+#include "rsCpuScriptGroup2.h"
 
 #include <malloc.h>
 #include "rsContext.h"
@@ -660,11 +661,19 @@
     return i;
 }
 
-RsdCpuReference::CpuScriptGroup * RsdCpuReferenceImpl::createScriptGroup(const ScriptGroup *sg) {
-    CpuScriptGroupImpl *sgi = new CpuScriptGroupImpl(this, sg);
-    if (!sgi->init()) {
+void* RsdCpuReferenceImpl::createScriptGroup(const ScriptGroupBase *sg) {
+  switch (sg->getApiVersion()) {
+    case ScriptGroupBase::SG_V1: {
+      CpuScriptGroupImpl *sgi = new CpuScriptGroupImpl(this, sg);
+      if (!sgi->init()) {
         delete sgi;
         return nullptr;
+      }
+      return sgi;
     }
-    return sgi;
+    case ScriptGroupBase::SG_V2: {
+      return new CpuScriptGroup2Impl(this, sg);
+    }
+  }
+  return nullptr;
 }
diff --git a/cpu_ref/rsCpuCore.h b/cpu_ref/rsCpuCore.h
index bfd5e51..e069658 100644
--- a/cpu_ref/rsCpuCore.h
+++ b/cpu_ref/rsCpuCore.h
@@ -182,7 +182,7 @@
                                      uint32_t flags);
     virtual CpuScript * createIntrinsic(const Script *s,
                                         RsScriptIntrinsicID iid, Element *e);
-    virtual CpuScriptGroup * createScriptGroup(const ScriptGroup *sg);
+    virtual void* createScriptGroup(const ScriptGroupBase *sg);
 
     const RsdCpuReference::CpuSymbol *symLookup(const char *);
 
diff --git a/cpu_ref/rsCpuScriptGroup.cpp b/cpu_ref/rsCpuScriptGroup.cpp
index 751bafb..3d32a51 100644
--- a/cpu_ref/rsCpuScriptGroup.cpp
+++ b/cpu_ref/rsCpuScriptGroup.cpp
@@ -18,15 +18,13 @@
 #include "rsCpuScript.h"
 #include "rsScriptGroup.h"
 #include "rsCpuScriptGroup.h"
-//#include "rsdBcc.h"
-//#include "rsdAllocation.h"
 
 using namespace android;
 using namespace android::renderscript;
 
-CpuScriptGroupImpl::CpuScriptGroupImpl(RsdCpuReferenceImpl *ctx, const ScriptGroup *sg) {
+CpuScriptGroupImpl::CpuScriptGroupImpl(RsdCpuReferenceImpl *ctx, const ScriptGroupBase *sg) {
     mCtx = ctx;
-    mSG = sg;
+    mSG = (ScriptGroup*)sg;
 }
 
 CpuScriptGroupImpl::~CpuScriptGroupImpl() {
diff --git a/cpu_ref/rsCpuScriptGroup.h b/cpu_ref/rsCpuScriptGroup.h
index 1a4af05..50ba2ac 100644
--- a/cpu_ref/rsCpuScriptGroup.h
+++ b/cpu_ref/rsCpuScriptGroup.h
@@ -30,7 +30,7 @@
     virtual void execute();
     virtual ~CpuScriptGroupImpl();
 
-    CpuScriptGroupImpl(RsdCpuReferenceImpl *ctx, const ScriptGroup *sg);
+    CpuScriptGroupImpl(RsdCpuReferenceImpl *ctx, const ScriptGroupBase *sg);
     bool init();
 
     static void scriptGroupRoot(const RsExpandKernelParams *p,
diff --git a/cpu_ref/rsCpuScriptGroup2.cpp b/cpu_ref/rsCpuScriptGroup2.cpp
new file mode 100644
index 0000000..9dc4d90
--- /dev/null
+++ b/cpu_ref/rsCpuScriptGroup2.cpp
@@ -0,0 +1,192 @@
+#include "rsCpuScriptGroup2.h"
+
+#include "cpu_ref/rsCpuCore.h"
+#include "rsClosure.h"
+#include "rsContext.h"
+#include "rsCpuCore.h"
+#include "rsCpuScript.h"
+#include "rsScript.h"
+#include "rsScriptGroup2.h"
+
+namespace android {
+namespace renderscript {
+
+namespace {
+
+static const size_t DefaultKernelArgCount = 2;
+
+void groupRoot(const RsExpandKernelParams *kparams, uint32_t xstart,
+               uint32_t xend, uint32_t outstep) {
+  const list<CPUClosure*>& closures = *(list<CPUClosure*>*)kparams->usr;
+  RsExpandKernelParams *mutable_kparams = (RsExpandKernelParams *)kparams;
+  const void **oldIns  = kparams->ins;
+  uint32_t *oldStrides = kparams->inEStrides;
+
+  std::vector<const void*> ins(DefaultKernelArgCount);
+  std::vector<uint32_t> strides(DefaultKernelArgCount);
+
+  for (CPUClosure* cpuClosure : closures) {
+    const Closure* closure = cpuClosure->mClosure;
+
+    auto in_iter = ins.begin();
+    auto stride_iter = strides.begin();
+
+    for (const auto& arg : closure->mArgs) {
+      const Allocation* a = (const Allocation*)arg;
+      const uint32_t eStride = a->mHal.state.elementSizeBytes;
+      const uint8_t* ptr = (uint8_t*)(a->mHal.drvState.lod[0].mallocPtr) +
+          eStride * xstart;
+      if (kparams->dimY > 1) {
+        ptr += a->mHal.drvState.lod[0].stride * kparams->y;
+      }
+      *in_iter++ = ptr;
+      *stride_iter++ = eStride;
+    }
+
+    mutable_kparams->ins = &ins[0];
+    mutable_kparams->inEStrides = &strides[0];
+
+    const Allocation* out = closure->mReturnValue;
+    const uint32_t ostep = out->mHal.state.elementSizeBytes;
+    const uint8_t* ptr = (uint8_t *)(out->mHal.drvState.lod[0].mallocPtr) +
+           ostep * xstart;
+    if (kparams->dimY > 1) {
+      ptr += out->mHal.drvState.lod[0].stride * kparams->y;
+    }
+
+    mutable_kparams->out = (void*)ptr;
+
+    mutable_kparams->usr = cpuClosure->mUsrPtr;
+
+    cpuClosure->mFunc(kparams, xstart, xend, ostep);
+  }
+
+  mutable_kparams->ins        = oldIns;
+  mutable_kparams->inEStrides = oldStrides;
+  mutable_kparams->usr        = &closures;
+}
+
+/*
+  Returns true if closure depends on any closure in batch via a glboal variable
+  TODO: this probably should go into class Closure.
+ */
+bool conflict(const list<CPUClosure*> &batch, CPUClosure* closure) {
+  for (const auto &p : closure->mClosure->mGlobalDeps) {
+    const Closure* dep = p.first;
+    for (CPUClosure* c : batch) {
+      if (c->mClosure == dep) {
+        return true;
+      }
+    }
+  }
+  for (const auto &p : closure->mClosure->mArgDeps) {
+    const Closure* dep = p.first;
+    for (CPUClosure* c : batch) {
+      if (c->mClosure == dep) {
+        for (const auto &p1 : *p.second) {
+          if (p1.second != nullptr) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+CpuScriptGroup2Impl::CpuScriptGroup2Impl(RsdCpuReferenceImpl *cpuRefImpl,
+                                         const ScriptGroupBase *sg) :
+    mCpuRefImpl(cpuRefImpl), mGroup((const ScriptGroup2*)(sg)) {
+  list<CPUClosure*>* batch = new list<CPUClosure*>();
+  for (Closure* closure: mGroup->mClosures) {
+    const ScriptKernelID* kernelID = closure->mKernelID.get();
+    RsdCpuScriptImpl* si =
+        (RsdCpuScriptImpl *)mCpuRefImpl->lookupScript(kernelID->mScript);
+
+    MTLaunchStruct mtls;
+    si->forEachKernelSetup(kernelID->mSlot, &mtls);
+    // TODO: Is mtls.fep.usrLen ever used?
+    CPUClosure* cc = new CPUClosure(closure, si, (ExpandFuncTy)mtls.kernel,
+                                    mtls.fep.usr, mtls.fep.usrLen);
+    if (conflict(*batch, cc)) {
+      mBatches.push_back(batch);
+      batch = new list<CPUClosure*>();
+    }
+    batch->push_back(cc);
+  }
+  mBatches.push_back(batch);
+}
+
+CpuScriptGroup2Impl::~CpuScriptGroup2Impl() {
+  for (list<CPUClosure*>* batch : mBatches) {
+    for (CPUClosure* c : *batch) {
+      delete c;
+    }
+  }
+}
+
+void CpuScriptGroup2Impl::execute() {
+  for (list<CPUClosure*>* batch : mBatches) {
+    setGlobalsForBatch(*batch);
+    runBatch(*batch);
+  }
+}
+
+void CpuScriptGroup2Impl::setGlobalsForBatch(const list<CPUClosure*>& batch) {
+  for (CPUClosure* cpuClosure : batch) {
+    const Closure* closure = cpuClosure->mClosure;
+    const ScriptKernelID* kernelID = closure->mKernelID.get();
+    Script* s = kernelID->mScript;
+    for (const auto& p : closure->mGlobals) {
+      const void* value = p.second.first;
+      int size = p.second.second;
+      // We use -1 size to indicate an ObjectBase rather than a primitive type
+      if (size < 0) {
+        s->setVarObj(p.first->mSlot, (ObjectBase*)value);
+      } else {
+        s->setVar(p.first->mSlot, (const void*)&value, size);
+      }
+    }
+  }
+}
+
+void CpuScriptGroup2Impl::runBatch(const list<CPUClosure*>& batch) {
+  for (CPUClosure* cpuClosure : batch) {
+    const Closure* closure = cpuClosure->mClosure;
+    const ScriptKernelID* kernelID = closure->mKernelID.get();
+    cpuClosure->mSi->preLaunch(kernelID->mSlot,
+                               (const Allocation**)&closure->mArgs[0],
+                               closure->mArgs.size(), closure->mReturnValue,
+                               cpuClosure->mUsrPtr, cpuClosure->mUsrSize,
+                               nullptr);
+  }
+
+  const CPUClosure* cpuClosure = batch.front();
+  const Closure* closure = cpuClosure->mClosure;
+  MTLaunchStruct mtls;
+
+  cpuClosure->mSi->forEachMtlsSetup((const Allocation**)&closure->mArgs[0],
+                                    closure->mArgs.size(),
+                                    closure->mReturnValue,
+                                    nullptr, 0, nullptr, &mtls);
+
+  mtls.script = nullptr;
+  mtls.kernel = (void (*)())&groupRoot;
+  mtls.fep.usr = &batch;
+
+  mCpuRefImpl->launchThreads(nullptr, 0, nullptr, nullptr, &mtls);
+
+  for (CPUClosure* cpuClosure : batch) {
+    const Closure* closure = cpuClosure->mClosure;
+    const ScriptKernelID* kernelID = closure->mKernelID.get();
+    cpuClosure->mSi->postLaunch(kernelID->mSlot,
+                                (const Allocation**)&closure->mArgs[0],
+                                closure->mArgs.size(), closure->mReturnValue,
+                                nullptr, 0, nullptr);
+  }
+}
+
+}  // namespace renderscript
+}  // namespace android
diff --git a/cpu_ref/rsCpuScriptGroup2.h b/cpu_ref/rsCpuScriptGroup2.h
new file mode 100644
index 0000000..6cb72a6
--- /dev/null
+++ b/cpu_ref/rsCpuScriptGroup2.h
@@ -0,0 +1,60 @@
+#ifndef CPU_REF_CPUSCRIPTGROUP2IMPL_H_
+#define CPU_REF_CPUSCRIPTGROUP2IMPL_H_
+
+#include <list>
+
+#include "rsd_cpu.h"
+
+using std::list;
+
+namespace android {
+namespace renderscript {
+
+class Closure;
+class RsdCpuScriptImpl;
+class RsdCpuReferenceImpl;
+class ScriptGroup2;
+
+struct RsExpandKernelParams;
+
+typedef void (*ExpandFuncTy)(const RsExpandKernelParams*, uint32_t, uint32_t,
+                             uint32_t);
+
+class CPUClosure {
+ public:
+  CPUClosure(const Closure* closure, RsdCpuScriptImpl* si, ExpandFuncTy func,
+             const void* usrPtr, const size_t usrSize) :
+      mClosure(closure), mSi(si), mFunc(func), mUsrPtr(usrPtr),
+      mUsrSize(usrSize) {}
+
+  // It's important to do forwarding here than inheritance for unbound value
+  // binding to work.
+  const Closure* mClosure;
+  RsdCpuScriptImpl* mSi;
+  const ExpandFuncTy mFunc;
+  const void* mUsrPtr;
+  const size_t mUsrSize;
+};
+
+class CpuScriptGroup2Impl : public RsdCpuReference::CpuScriptGroup2 {
+ public:
+  CpuScriptGroup2Impl(RsdCpuReferenceImpl *cpuRefImpl, const ScriptGroupBase* group);
+  virtual ~CpuScriptGroup2Impl();
+
+  bool init();
+  virtual void execute();
+
+ private:
+  void setGlobalsForBatch(const list<CPUClosure*>& batch);
+  void runBatch(const list<CPUClosure*>& batch);
+
+  RsdCpuReferenceImpl* mCpuRefImpl;
+  const ScriptGroup2* mGroup;
+
+  list<list<CPUClosure*>*> mBatches;
+};
+
+}  // namespace renderscript
+}  // namespace android
+
+#endif  // CPU_REF_CPUSCRIPTGROUP2IMPL_H_
diff --git a/cpu_ref/rsd_cpu.h b/cpu_ref/rsd_cpu.h
index b0e924e..d886cef 100644
--- a/cpu_ref/rsd_cpu.h
+++ b/cpu_ref/rsd_cpu.h
@@ -45,7 +45,7 @@
 
 class ScriptC;
 class Script;
-class ScriptGroup;
+class ScriptGroupBase;
 class ScriptKernelID;
 
 
@@ -97,7 +97,13 @@
     };
     typedef CpuScript * (* script_lookup_t)(Context *, const Script *s);
 
-    class CpuScriptGroup {
+    class CpuScriptGroupBase {
+     public:
+      virtual void execute() = 0;
+      virtual ~CpuScriptGroupBase() {}
+    };
+
+    class CpuScriptGroup : public CpuScriptGroupBase {
     public:
         virtual void setInput(const ScriptKernelID *kid, Allocation *) = 0;
         virtual void setOutput(const ScriptKernelID *kid, Allocation *) = 0;
@@ -105,6 +111,12 @@
         virtual ~CpuScriptGroup() {};
     };
 
+    class CpuScriptGroup2 : public CpuScriptGroupBase {
+     public:
+      virtual void execute() = 0;
+      virtual ~CpuScriptGroup2() {}
+    };
+
     static Context * getTlsContext();
     static const Script * getTlsScript();
     static pthread_key_t getThreadTLSKey();
@@ -124,7 +136,7 @@
                                      uint8_t const *bitcode, size_t bitcodeSize,
                                      uint32_t flags) = 0;
     virtual CpuScript * createIntrinsic(const Script *s, RsScriptIntrinsicID iid, Element *e) = 0;
-    virtual CpuScriptGroup * createScriptGroup(const ScriptGroup *sg) = 0;
+    virtual void* createScriptGroup(const ScriptGroupBase *sg) = 0;
     virtual bool getInForEach() = 0;
 
 #ifndef RS_COMPATIBILITY_LIB
diff --git a/driver/rsdScriptGroup.cpp b/driver/rsdScriptGroup.cpp
index a7b2e77..ed800a3 100644
--- a/driver/rsdScriptGroup.cpp
+++ b/driver/rsdScriptGroup.cpp
@@ -28,7 +28,7 @@
 using namespace android::renderscript;
 
 
-bool rsdScriptGroupInit(const Context *rsc, ScriptGroup *sg) {
+bool rsdScriptGroupInit(const Context *rsc, ScriptGroupBase *sg) {
     RsdHal *dc = (RsdHal *)rsc->mHal.drv;
 
     sg->mHal.drv = dc->mCpuRef->createScriptGroup(sg);
@@ -43,13 +43,15 @@
                              const ScriptKernelID *kid, Allocation *) {
 }
 
-void rsdScriptGroupExecute(const Context *rsc, const ScriptGroup *sg) {
-    RsdCpuReference::CpuScriptGroup *sgi = (RsdCpuReference::CpuScriptGroup *)sg->mHal.drv;
+void rsdScriptGroupExecute(const Context *rsc, const ScriptGroupBase *sg) {
+    RsdCpuReference::CpuScriptGroupBase *sgi =
+        (RsdCpuReference::CpuScriptGroupBase *)sg->mHal.drv;
     sgi->execute();
 }
 
-void rsdScriptGroupDestroy(const Context *rsc, const ScriptGroup *sg) {
-    RsdCpuReference::CpuScriptGroup *sgi = (RsdCpuReference::CpuScriptGroup *)sg->mHal.drv;
+void rsdScriptGroupDestroy(const Context *rsc, const ScriptGroupBase *sg) {
+    RsdCpuReference::CpuScriptGroupBase *sgi =
+        (RsdCpuReference::CpuScriptGroupBase *)sg->mHal.drv;
     delete sgi;
 }
 
@@ -68,5 +70,3 @@
     obj->v2 = nullptr;
 #endif
 }
-
-
diff --git a/driver/rsdScriptGroup.h b/driver/rsdScriptGroup.h
index db44e23..95e5d19 100644
--- a/driver/rsdScriptGroup.h
+++ b/driver/rsdScriptGroup.h
@@ -20,7 +20,7 @@
 #include <rs_hal.h>
 
 bool rsdScriptGroupInit(const android::renderscript::Context *rsc,
-                        android::renderscript::ScriptGroup *sg);
+                        android::renderscript::ScriptGroupBase *sg);
 void rsdScriptGroupSetInput(const android::renderscript::Context *rsc,
                             const android::renderscript::ScriptGroup *sg,
                             const android::renderscript::ScriptKernelID *kid,
@@ -30,9 +30,9 @@
                              const android::renderscript::ScriptKernelID *kid,
                              android::renderscript::Allocation *);
 void rsdScriptGroupExecute(const android::renderscript::Context *rsc,
-                           const android::renderscript::ScriptGroup *sg);
+                           const android::renderscript::ScriptGroupBase *sg);
 void rsdScriptGroupDestroy(const android::renderscript::Context *rsc,
-                           const android::renderscript::ScriptGroup *sg);
+                           const android::renderscript::ScriptGroupBase *sg);
 void rsdScriptGroupUpdateCachedObject(const android::renderscript::Context *rsc,
                                       const android::renderscript::ScriptGroup *sg,
                                       android::renderscript::rs_script_group *obj);
diff --git a/rs.spec b/rs.spec
index 18ece8c..22c53b9 100644
--- a/rs.spec
+++ b/rs.spec
@@ -252,6 +252,31 @@
     param uint32_t srcMip
     }
 
+ClosureCreate {
+    direct
+    param RsScriptKernelID kernelID
+    param RsAllocation returnValue
+    param RsScriptFieldID * fieldIDs
+    param uintptr_t * values
+    param size_t * sizes
+    param RsClosure * depClosures
+    param RsScriptFieldID * depFieldIDs
+    ret RsClosure
+    }
+
+ClosureSetArg {
+  param RsClosure closureID
+  param uint32_t index
+  param uintptr_t value
+  param size_t valueSize
+}
+
+ClosureSetGlobal {
+  param RsClosure closureID
+  param RsScriptFieldID fieldID
+  param uintptr_t value
+  param size_t valueSize
+}
 
 SamplerCreate {
     direct
@@ -410,6 +435,12 @@
     param RsScriptGroup group
 }
 
+ScriptGroup2Create{
+    direct
+    param RsClosure * closures
+    ret RsScriptGroup2
+}
+
 AllocationIoSend {
     param RsAllocation alloc
     }
diff --git a/rsClosure.cpp b/rsClosure.cpp
new file mode 100644
index 0000000..8530fc1
--- /dev/null
+++ b/rsClosure.cpp
@@ -0,0 +1,147 @@
+#include "rsClosure.h"
+
+#include "cpu_ref/rsCpuCore.h"
+#include "rsContext.h" // XXX: necessary to avoid compiler error on rsScript.h below
+#include "rsScript.h"
+#include "rsType.h"
+
+namespace android {
+namespace renderscript {
+
+RsClosure rsi_ClosureCreate(Context* context, RsScriptKernelID kernelID,
+                            RsAllocation returnValue,
+                            RsScriptFieldID* fieldIDs, size_t fieldIDs_length,
+                            uintptr_t* values, size_t values_length,
+                            size_t* sizes, size_t sizes_length,
+                            RsClosure* depClosures, size_t depClosures_length,
+                            RsScriptFieldID* depFieldIDs,
+                            size_t depFieldIDs_length) {
+  rsAssert(fieldIDs_length == values_length && values_length == sizes_length &&
+           sizes_length == depClosures_length &&
+           depClosures_length == depFieldIDs_length);
+
+  return (RsClosure)(new Closure(
+      context, (const ScriptKernelID*)kernelID, (Allocation*)returnValue,
+      fieldIDs_length, (const ScriptFieldID**)fieldIDs, (const void**)values,
+      sizes, (const Closure**)depClosures,
+      (const ScriptFieldID**)depFieldIDs));
+}
+
+void rsi_ClosureEval(Context* rsc, RsClosure closure) {
+  ((Closure*)closure)->eval();
+}
+
+void rsi_ClosureSetArg(Context* rsc, RsClosure closure, uint32_t index,
+                       uintptr_t value, size_t size) {
+  ((Closure*)closure)->setArg(index, (const void*)value, size);
+}
+
+void rsi_ClosureSetGlobal(Context* rsc, RsClosure closure,
+                          RsScriptFieldID fieldID, uintptr_t value,
+                          size_t size) {
+  ((Closure*)closure)->setGlobal((const ScriptFieldID*)fieldID,
+                                 (const void*)value, size);
+}
+
+Closure::Closure(Context* context,
+                 const ScriptKernelID* kernelID,
+                 Allocation* returnValue,
+                 const int numValues,
+                 const ScriptFieldID** fieldIDs,
+                 const void** values,
+                 const size_t* sizes,
+                 const Closure** depClosures,
+                 const ScriptFieldID** depFieldIDs) :
+    ObjectBase(context), mContext(context), mKernelID((ScriptKernelID*)kernelID),
+    mReturnValue(returnValue) {
+  size_t i;
+
+  for (i = 0; i < (size_t)numValues && fieldIDs[i] == nullptr; i++);
+
+  vector<const void*> args(values, values + i);
+  mArgs.swap(args);
+
+  for (; i < (size_t)numValues; i++) {
+    mGlobals[fieldIDs[i]] = std::make_pair(values[i], sizes[i]);
+  }
+
+  mDependences.insert(depClosures, depClosures + numValues);
+
+  for (i = 0; i < mArgs.size(); i++) {
+    const Closure* dep = depClosures[i];
+    if (dep != nullptr) {
+      auto mapping = mArgDeps[dep];
+      if (mapping == nullptr) {
+        mapping = new map<int, const ObjectBaseRef<ScriptFieldID>*>();
+        mArgDeps[dep] = mapping;
+      }
+      (*mapping)[i] = new ObjectBaseRef<ScriptFieldID>(
+          const_cast<ScriptFieldID*>(depFieldIDs[i]));
+    }
+  }
+
+  for (; i < (size_t)numValues; i++) {
+    const Closure* dep = depClosures[i];
+    if (dep != nullptr) {
+      auto mapping = mGlobalDeps[dep];
+      if (mapping == nullptr) {
+        mapping = new map<const ObjectBaseRef<ScriptFieldID>*,
+            const ObjectBaseRef<ScriptFieldID>*>();
+        mGlobalDeps[dep] = mapping;
+      }
+      (*mapping)[new ObjectBaseRef<ScriptFieldID>(
+          const_cast<ScriptFieldID*>(fieldIDs[i]))] =
+          new ObjectBaseRef<ScriptFieldID>(
+              const_cast<ScriptFieldID*>(depFieldIDs[i]));
+    }
+  }
+}
+
+Closure::~Closure() {
+  for (const auto& p : mArgDeps) {
+    auto map = p.second;
+    for (const auto& p1 : *map) {
+      delete p1.second;
+    }
+    delete p.second;
+  }
+
+  for (const auto& p : mGlobalDeps) {
+    auto map = p.second;
+    for (const auto& p1 : *map) {
+      delete p1.first;
+      delete p1.second;
+    }
+    delete p.second;
+  }
+}
+
+void Closure::eval() {
+  Script *s = mKernelID->mScript;
+
+  for (const auto& p : mGlobals) {
+    const void* value = p.second.first;
+    int size = p.second.second;
+    // We use -1 size to indicate an ObjectBase rather than a primitive type
+    if (size < 0) {
+      s->setVarObj(p.first->mSlot, (ObjectBase*)value);
+    } else {
+      s->setVar(p.first->mSlot, (const void*)&value, size);
+    }
+  }
+
+  s->runForEach(mContext, mKernelID->mSlot, (const Allocation **)(&mArgs[0]),
+                mArgs.size(), mReturnValue, nullptr, 0, nullptr);
+}
+
+void Closure::setArg(const uint32_t index, const void* value, const size_t size) {
+  mArgs[index] = value;
+}
+
+void Closure::setGlobal(const ScriptFieldID* fieldID, const void* value,
+                        const size_t size) {
+  mGlobals[fieldID] = std::make_pair(value, size);
+}
+
+}  // namespace renderscript
+}  // namespace android
diff --git a/rsClosure.h b/rsClosure.h
new file mode 100644
index 0000000..372cd32
--- /dev/null
+++ b/rsClosure.h
@@ -0,0 +1,78 @@
+#ifndef ANDROID_RENDERSCRIPT_CLOSURE_H_
+#define ANDROID_RENDERSCRIPT_CLOSURE_H_
+
+#include <map>
+#include <set>
+#include <vector>
+
+#include "rsDefines.h"
+#include "rsObjectBase.h"
+
+namespace android {
+namespace renderscript {
+
+using std::map;
+using std::pair;
+using std::set;
+using std::vector;
+
+class Allocation;
+class Context;
+class ScriptFieldID;
+class ScriptKernelID;
+class Type;
+
+class Closure : public ObjectBase {
+ public:
+  Closure(Context* context,
+          const ScriptKernelID* kernelID,
+          Allocation* returnValue,
+          const int numValues,
+          const ScriptFieldID** fieldIDs,
+          const void** values,  // Allocations or primitive (numeric) types
+          const size_t* sizes,   // size for data type. -1 indicates an allocation.
+          const Closure** depClosures,
+          const ScriptFieldID** depFieldIDs);
+
+  virtual ~Closure();
+
+  virtual void serialize(Context *rsc, OStream *stream) const {}
+
+  virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_CLOSURE; }
+
+  void eval();
+
+  void setArg(const uint32_t index, const void* value, const size_t size);
+  void setGlobal(const ScriptFieldID* fieldID, const void* value,
+                 const size_t size);
+
+  Context* mContext;
+  const ObjectBaseRef<ScriptKernelID> mKernelID;
+
+  // Values referrenced in arguments and globals cannot be futures. They must be
+  // either a known value or unbound value.
+  // For now, all arguments should be Allocations.
+  vector<const void*> mArgs;
+
+  // A global could be allocation or any primitive data type.
+  map<const ScriptFieldID*, pair<const void*, int>> mGlobals;
+
+  Allocation* mReturnValue;
+
+  // All the other closures that this closure depends on
+  set<const Closure*> mDependences;
+
+  // All the other closures which this closure depends on for one of its
+  // arguments, and the fields which it depends on.
+  map<const Closure*, map<int, const ObjectBaseRef<ScriptFieldID>*>*> mArgDeps;
+
+  // All the other closures that this closure depends on for one of its fields,
+  // and the fields that it depends on.
+  map<const Closure*, map<const ObjectBaseRef<ScriptFieldID>*,
+                          const ObjectBaseRef<ScriptFieldID>*>*> mGlobalDeps;
+};
+
+}  // namespace renderscript
+}  // namespace android
+
+#endif  // ANDROID_RENDERSCRIPT_CLOSURE_H_
diff --git a/rsDefines.h b/rsDefines.h
index 0a91ea8..9345eb9 100644
--- a/rsDefines.h
+++ b/rsDefines.h
@@ -33,6 +33,7 @@
 typedef void * RsAdapter2D;
 typedef void * RsAllocation;
 typedef void * RsAnimation;
+typedef void * RsClosure;
 typedef void * RsContext;
 typedef void * RsDevice;
 typedef void * RsElement;
@@ -44,6 +45,7 @@
 typedef void * RsScriptFieldID;
 typedef void * RsScriptMethodID;
 typedef void * RsScriptGroup;
+typedef void * RsScriptGroup2;
 typedef void * RsMesh;
 typedef void * RsPath;
 typedef void * RsType;
@@ -251,7 +253,3 @@
 #endif
 
 #endif // RENDER_SCRIPT_DEFINES_H
-
-
-
-
diff --git a/rsFileA3D.cpp b/rsFileA3D.cpp
index 6f14637..3fe6942 100644
--- a/rsFileA3D.cpp
+++ b/rsFileA3D.cpp
@@ -294,6 +294,10 @@
             break;
         case RS_A3D_CLASS_ID_SCRIPT_GROUP:
             break;
+        case RS_A3D_CLASS_ID_CLOSURE:
+            break;
+        case RS_A3D_CLASS_ID_SCRIPT_GROUP2:
+            break;
     }
     if (entry->mRsObj) {
         entry->mRsObj->incUserRef();
diff --git a/rsInternalDefines.h b/rsInternalDefines.h
index 19f2122..57cb72a 100644
--- a/rsInternalDefines.h
+++ b/rsInternalDefines.h
@@ -163,7 +163,9 @@
     RS_A3D_CLASS_ID_SCRIPT_KERNEL_ID,
     RS_A3D_CLASS_ID_SCRIPT_FIELD_ID,
     RS_A3D_CLASS_ID_SCRIPT_METHOD_ID,
-    RS_A3D_CLASS_ID_SCRIPT_GROUP
+    RS_A3D_CLASS_ID_SCRIPT_GROUP,
+    RS_A3D_CLASS_ID_CLOSURE,
+    RS_A3D_CLASS_ID_SCRIPT_GROUP2
 };
 
 enum RsCullMode {
@@ -202,7 +204,3 @@
 #endif
 
 #endif // RENDER_SCRIPT_DEFINES_H
-
-
-
-
diff --git a/rsScriptGroup.cpp b/rsScriptGroup.cpp
index 618c28c..791ab14 100644
--- a/rsScriptGroup.cpp
+++ b/rsScriptGroup.cpp
@@ -14,15 +14,18 @@
  * limitations under the License.
  */
 
-#include <algorithm>
+#include "rsScriptGroup.h"
 
 #include "rsContext.h"
+#include "rsScriptGroup2.h"
+
+#include <algorithm>
 #include <time.h>
 
 using namespace android;
 using namespace android::renderscript;
 
-ScriptGroup::ScriptGroup(Context *rsc) : ObjectBase(rsc) {
+ScriptGroup::ScriptGroup(Context *rsc) : ScriptGroupBase(rsc) {
 }
 
 ScriptGroup::~ScriptGroup() {
@@ -270,12 +273,10 @@
 }
 
 void ScriptGroup::execute(Context *rsc) {
-
     if (!validateInputAndOutput(rsc)) {
         return;
     }
 
-    //ALOGE("ScriptGroup::execute");
     if (rsc->mHal.funcs.scriptgroup.execute) {
         rsc->mHal.funcs.scriptgroup.execute(rsc, this);
         return;
@@ -324,13 +325,6 @@
 
 }
 
-void ScriptGroup::serialize(Context *rsc, OStream *stream) const {
-}
-
-RsA3DClassID ScriptGroup::getClassId() const {
-    return RS_A3D_CLASS_ID_SCRIPT_GROUP;
-}
-
 ScriptGroup::Link::Link() {
 }
 
@@ -371,7 +365,7 @@
 }
 
 void rsi_ScriptGroupExecute(Context *rsc, RsScriptGroup sg) {
-    ScriptGroup *s = (ScriptGroup *)sg;
+    ScriptGroupBase *s = (ScriptGroupBase *)sg;
     s->execute(rsc);
 }
 
diff --git a/rsScriptGroup.h b/rsScriptGroup.h
index 974e3ba..ff0259a 100644
--- a/rsScriptGroup.h
+++ b/rsScriptGroup.h
@@ -17,21 +17,30 @@
 #ifndef ANDROID_RS_SCRIPT_GROUP_H
 #define ANDROID_RS_SCRIPT_GROUP_H
 
-#include "rsAllocation.h"
-#include "rsScript.h"
+#include "rsScriptGroupBase.h"
 
+#include <vector>
 
 // ---------------------------------------------------------------------------
 namespace android {
 namespace renderscript {
 
+class Allocation;
+class Context;
 class ProgramVertex;
 class ProgramFragment;
 class ProgramRaster;
 class ProgramStore;
+class Script;
+class ScriptFieldID;
+class ScriptKernelID;
+class Type;
 
-class ScriptGroup : public ObjectBase {
+class ScriptGroup : public ScriptGroupBase {
 public:
+    virtual SG_API_Version getApiVersion() const { return SG_V1; }
+    virtual void execute(Context *rsc);
+
     std::vector<ObjectBaseRef<ScriptKernelID> > mKernels;
 
     class Link {
@@ -70,15 +79,6 @@
     std::vector<IO *> mInputs;
     std::vector<IO *> mOutputs;
 
-    struct Hal {
-        void * drv;
-
-        struct DriverInfo {
-        };
-        DriverInfo info;
-    };
-    Hal mHal;
-
     static ScriptGroup * create(Context *rsc,
                            ScriptKernelID ** kernels, size_t kernelsSize,
                            ScriptKernelID ** src, size_t srcSize,
@@ -86,14 +86,9 @@
                            ScriptFieldID ** dstF, size_t dstFSize,
                            const Type ** type, size_t typeSize);
 
-    virtual void serialize(Context *rsc, OStream *stream) const;
-    virtual RsA3DClassID getClassId() const;
-
-    void execute(Context *rsc);
     void setInput(Context *rsc, ScriptKernelID *kid, Allocation *a);
     void setOutput(Context *rsc, ScriptKernelID *kid, Allocation *a);
 
-
 protected:
     virtual ~ScriptGroup();
     bool mInitialized;
diff --git a/rsScriptGroup2.cpp b/rsScriptGroup2.cpp
new file mode 100644
index 0000000..06a252a
--- /dev/null
+++ b/rsScriptGroup2.cpp
@@ -0,0 +1,27 @@
+#include "rsScriptGroup2.h"
+
+#include "rsContext.h"
+
+namespace android {
+namespace renderscript {
+
+void ScriptGroup2::execute(Context* rsc) {
+  if (rsc->mHal.funcs.scriptgroup.execute) {
+    rsc->mHal.funcs.scriptgroup.execute(rsc, this);
+  }
+}
+
+RsScriptGroup2 rsi_ScriptGroup2Create(Context* rsc, RsClosure* closures,
+                                      size_t numClosures) {
+  ScriptGroup2* group = new ScriptGroup2(rsc, (Closure**)closures, numClosures);
+
+  // Create a device-specific implementation by calling the device driver
+  if (rsc->mHal.funcs.scriptgroup.init) {
+    rsc->mHal.funcs.scriptgroup.init(rsc, group);
+  }
+
+  return group;
+}
+
+}  // namespace renderscript
+}  // namespace android
diff --git a/rsScriptGroup2.h b/rsScriptGroup2.h
new file mode 100644
index 0000000..c759faf
--- /dev/null
+++ b/rsScriptGroup2.h
@@ -0,0 +1,36 @@
+#ifndef ANDROID_RENDERSCRIPT_SCRIPTGROUP2_H_
+#define ANDROID_RENDERSCRIPT_SCRIPTGROUP2_H_
+
+#include "rsScriptGroupBase.h"
+
+#include <list>
+
+namespace android {
+namespace renderscript {
+
+class Closure;
+class Context;
+
+class ScriptGroup2 : public ScriptGroupBase {
+ public:
+  /*
+    TODO:
+    Inputs and outputs are set and retrieved in Java runtime.
+    They are opaque in the C++ runtime.
+    For better compiler optimizations (of a script group), we need to include
+    input and output information in the C++ runtime.
+   */
+  ScriptGroup2(Context* rsc, Closure** closures, size_t numClosures) :
+      ScriptGroupBase(rsc), mClosures(closures, closures + numClosures) {}
+  virtual ~ScriptGroup2() {}
+
+  virtual SG_API_Version getApiVersion() const { return SG_V2; }
+  virtual void execute(Context* rsc);
+
+  std::list<Closure*> mClosures;
+};
+
+}  // namespace renderscript
+}  // namespace android
+
+#endif  // ANDROID_RENDERSCRIPT_SCRIPTGROUP2_H_
diff --git a/rsScriptGroupBase.h b/rsScriptGroupBase.h
new file mode 100644
index 0000000..00ae6c6
--- /dev/null
+++ b/rsScriptGroupBase.h
@@ -0,0 +1,41 @@
+#ifndef ANDROID_RS_SCRIPT_GROUP_BASE_H
+#define ANDROID_RS_SCRIPT_GROUP_BASE_H
+
+#include "rsObjectBase.h"
+
+namespace android {
+namespace renderscript {
+
+class ScriptGroupBase : public ObjectBase {
+ public:
+  ScriptGroupBase(Context* rsc) : ObjectBase(rsc) {}
+  virtual ~ScriptGroupBase() {}
+
+  virtual void serialize(Context *rsc, OStream *stream) const {}
+
+  virtual RsA3DClassID getClassId() const {
+    return RS_A3D_CLASS_ID_SCRIPT_GROUP;
+  }
+
+  enum SG_API_Version {
+    SG_V1 = 10,
+    SG_V2 = 20,
+  };
+
+  virtual void execute(Context *rsc) = 0;
+  virtual SG_API_Version getApiVersion() const = 0;
+
+  struct Hal {
+    void * drv;
+
+    struct DriverInfo {
+    };
+    DriverInfo info;
+  };
+  Hal mHal;
+};
+
+}  // namespace renderscript
+}  // namespace android
+
+#endif  // ANDROID_RS_SCRIPT_GROUP_BASE_H
diff --git a/rs_hal.h b/rs_hal.h
index 419827b..b3c2e39 100644
--- a/rs_hal.h
+++ b/rs_hal.h
@@ -35,6 +35,7 @@
 class ScriptMethodID;
 class ScriptC;
 class ScriptGroup;
+class ScriptGroupBase;
 class Path;
 class Program;
 class ProgramStore;
@@ -300,13 +301,13 @@
     } framebuffer;
 
     struct {
-        bool (*init)(const Context *rsc, ScriptGroup *sg);
+        bool (*init)(const Context *rsc, ScriptGroupBase *sg);
         void (*setInput)(const Context *rsc, const ScriptGroup *sg,
                          const ScriptKernelID *kid, Allocation *);
         void (*setOutput)(const Context *rsc, const ScriptGroup *sg,
                           const ScriptKernelID *kid, Allocation *);
-        void (*execute)(const Context *rsc, const ScriptGroup *sg);
-        void (*destroy)(const Context *rsc, const ScriptGroup *sg);
+        void (*execute)(const Context *rsc, const ScriptGroupBase *sg);
+        void (*destroy)(const Context *rsc, const ScriptGroupBase *sg);
         void (*updateCachedObject)(const Context *rsc, const ScriptGroup *sg, rs_script_group *obj);
     } scriptgroup;