diff --git a/Demos3/BasicDemo/BasicDemo.cpp b/Demos3/BasicDemo/BasicDemo.cpp
new file mode 100644
index 000000000..ae223626f
--- /dev/null
+++ b/Demos3/BasicDemo/BasicDemo.cpp
@@ -0,0 +1,242 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+///create 125 (5x5x5) dynamic object
+#define ARRAY_SIZE_X 5
+#define ARRAY_SIZE_Y 5
+#define ARRAY_SIZE_Z 5
+
+//maximum number of objects (and allow user to shoot additional boxes)
+#define MAX_PROXIES (ARRAY_SIZE_X*ARRAY_SIZE_Y*ARRAY_SIZE_Z + 1024)
+
+///scaling of the objects (0.1 = 20 centimeter boxes )
+#define SCALING 1.
+#define START_POS_X -5
+#define START_POS_Y -5
+#define START_POS_Z -3
+
+#include "BasicDemo.h"
+#include "GlutStuff.h"
+///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
+#include "btBulletDynamicsCommon.h"
+
+#include <stdio.h> //printf debugging
+#include "GLDebugDrawer.h"
+
+static GLDebugDrawer gDebugDraw;
+
+
+void BasicDemo::clientMoveAndDisplay()
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+
+	//simple dynamics world doesn't handle fixed-time-stepping
+	float ms = getDeltaTimeMicroseconds();
+	
+	///step the simulation
+	if (m_dynamicsWorld)
+	{
+		m_dynamicsWorld->stepSimulation(ms / 1000000.f);
+		//optional but useful: debug drawing
+		m_dynamicsWorld->debugDrawWorld();
+	}
+		
+	renderme(); 
+
+	glFlush();
+
+	swapBuffers();
+
+}
+
+
+
+void BasicDemo::displayCallback(void) {
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+	
+	renderme();
+
+	//optional but useful: debug drawing to detect problems
+	if (m_dynamicsWorld)
+		m_dynamicsWorld->debugDrawWorld();
+
+	glFlush();
+	swapBuffers();
+}
+
+
+
+
+
+void	BasicDemo::initPhysics()
+{
+	setTexturing(true);
+	setShadows(true);
+
+	setCameraDistance(btScalar(SCALING*50.));
+
+	///collision configuration contains default setup for memory, collision setup
+	m_collisionConfiguration = new btDefaultCollisionConfiguration();
+	//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+	///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+	m_dispatcher = new	btCollisionDispatcher(m_collisionConfiguration);
+
+	m_broadphase = new btDbvtBroadphase();
+
+	///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+	btSequentialImpulseConstraintSolver* sol = new btSequentialImpulseConstraintSolver;
+	m_solver = sol;
+
+	m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
+	m_dynamicsWorld->setDebugDrawer(&gDebugDraw);
+	
+	m_dynamicsWorld->setGravity(btVector3(0,-10,0));
+
+	///create a few basic rigid bodies
+	btBoxShape* groundShape = new btBoxShape(btVector3(btScalar(50.),btScalar(50.),btScalar(50.)));
+	//groundShape->initializePolyhedralFeatures();
+//	btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0),50);
+	
+	m_collisionShapes.push_back(groundShape);
+
+	btTransform groundTransform;
+	groundTransform.setIdentity();
+	groundTransform.setOrigin(btVector3(0,-50,0));
+
+	//We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+	{
+		btScalar mass(0.);
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0,0,0);
+		if (isDynamic)
+			groundShape->calculateLocalInertia(mass,localInertia);
+
+		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
+		btRigidBody* body = new btRigidBody(rbInfo);
+
+		//add the body to the dynamics world
+		m_dynamicsWorld->addRigidBody(body);
+	}
+
+
+	{
+		//create a few dynamic rigidbodies
+		// Re-using the same collision is better for memory usage and performance
+
+		btBoxShape* colShape = new btBoxShape(btVector3(SCALING*1,SCALING*1,SCALING*1));
+		//btCollisionShape* colShape = new btSphereShape(btScalar(1.));
+		m_collisionShapes.push_back(colShape);
+
+		/// Create Dynamic Objects
+		btTransform startTransform;
+		startTransform.setIdentity();
+
+		btScalar	mass(1.f);
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0,0,0);
+		if (isDynamic)
+			colShape->calculateLocalInertia(mass,localInertia);
+
+		float start_x = START_POS_X - ARRAY_SIZE_X/2;
+		float start_y = START_POS_Y;
+		float start_z = START_POS_Z - ARRAY_SIZE_Z/2;
+
+		for (int k=0;k<ARRAY_SIZE_Y;k++)
+		{
+			for (int i=0;i<ARRAY_SIZE_X;i++)
+			{
+				for(int j = 0;j<ARRAY_SIZE_Z;j++)
+				{
+					startTransform.setOrigin(SCALING*btVector3(
+										btScalar(2.0*i + start_x),
+										btScalar(20+2.0*k + start_y),
+										btScalar(2.0*j + start_z)));
+
+			
+					//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+					btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+					btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,colShape,localInertia);
+					btRigidBody* body = new btRigidBody(rbInfo);
+					
+
+					m_dynamicsWorld->addRigidBody(body);
+				}
+			}
+		}
+	}
+
+
+}
+void	BasicDemo::clientResetScene()
+{
+	exitPhysics();
+	initPhysics();
+}
+	
+
+void	BasicDemo::exitPhysics()
+{
+
+	//cleanup in the reverse order of creation/initialization
+
+	//remove the rigidbodies from the dynamics world and delete them
+	int i;
+	for (i=m_dynamicsWorld->getNumCollisionObjects()-1; i>=0 ;i--)
+	{
+		btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+		btRigidBody* body = btRigidBody::upcast(obj);
+		if (body && body->getMotionState())
+		{
+			delete body->getMotionState();
+		}
+		m_dynamicsWorld->removeCollisionObject( obj );
+		delete obj;
+	}
+
+	//delete collision shapes
+	for (int j=0;j<m_collisionShapes.size();j++)
+	{
+		btCollisionShape* shape = m_collisionShapes[j];
+		delete shape;
+	}
+	m_collisionShapes.clear();
+
+	delete m_dynamicsWorld;
+	
+	delete m_solver;
+	
+	delete m_broadphase;
+	
+	delete m_dispatcher;
+
+	delete m_collisionConfiguration;
+
+	
+}
+
+
+
+
diff --git a/Demos3/BasicDemo/BasicDemo.h b/Demos3/BasicDemo/BasicDemo.h
new file mode 100644
index 000000000..7a6851f7d
--- /dev/null
+++ b/Demos3/BasicDemo/BasicDemo.h
@@ -0,0 +1,82 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef BASIC_DEMO_H
+#define BASIC_DEMO_H
+
+#ifdef _WINDOWS
+#include "Win32DemoApplication.h"
+#define PlatformDemoApplication Win32DemoApplication
+#else
+#include "GlutDemoApplication.h"
+#define PlatformDemoApplication GlutDemoApplication
+#endif
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+class btBroadphaseInterface;
+class btCollisionShape;
+class btOverlappingPairCache;
+class btCollisionDispatcher;
+class btConstraintSolver;
+struct btCollisionAlgorithmCreateFunc;
+class btDefaultCollisionConfiguration;
+
+///BasicDemo is good starting point for learning the code base and porting.
+
+class BasicDemo : public PlatformDemoApplication
+{
+
+	//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
+
+	btBroadphaseInterface*	m_broadphase;
+
+	btCollisionDispatcher*	m_dispatcher;
+
+	btConstraintSolver*	m_solver;
+
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+
+	public:
+
+	BasicDemo()
+	{
+	}
+	virtual ~BasicDemo()
+	{
+		exitPhysics();
+	}
+	void	initPhysics();
+
+	void	exitPhysics();
+
+	virtual void clientMoveAndDisplay();
+
+	virtual void displayCallback();
+	virtual void	clientResetScene();
+	
+	static DemoApplication* Create()
+	{
+		BasicDemo* demo = new BasicDemo;
+		demo->myinit();
+		demo->initPhysics();
+		return demo;
+	}
+
+	
+};
+
+#endif //BASIC_DEMO_H
+
diff --git a/Demos3/BasicDemo/CMakeLists.txt b/Demos3/BasicDemo/CMakeLists.txt
new file mode 100644
index 000000000..253b8b47c
--- /dev/null
+++ b/Demos3/BasicDemo/CMakeLists.txt
@@ -0,0 +1,87 @@
+# This is basically the overall name of the project in Visual Studio this is the name of the Solution File
+
+
+# For every executable you have with a main method you should have an add_executable line below.
+# For every add executable line you should list every .cpp and .h file you have associated with that executable.  
+
+
+# This is the variable for Windows.  I use this to define the root of my directory structure.
+SET(GLUT_ROOT ${BULLET_PHYSICS_SOURCE_DIR}/Glut)
+
+# You shouldn't have to modify anything below this line 
+########################################################
+
+INCLUDE_DIRECTORIES(
+${BULLET_PHYSICS_SOURCE_DIR}/src ${BULLET_PHYSICS_SOURCE_DIR}/Demos/OpenGL 
+)
+
+
+
+IF (USE_GLUT)
+	LINK_LIBRARIES(
+	OpenGLSupport  BulletDynamics  BulletCollision LinearMath  ${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY}
+	)
+
+IF (WIN32)
+ADD_EXECUTABLE(AppBasicDemo
+		main.cpp
+		BasicDemo.cpp 
+		BasicDemo.h
+		${BULLET_PHYSICS_SOURCE_DIR}/build/bullet.rc
+	)
+ELSE()
+	ADD_EXECUTABLE(AppBasicDemo
+		main.cpp
+		BasicDemo.cpp 
+		BasicDemo.h
+	)
+ENDIF()
+
+
+
+
+	IF (WIN32)
+		IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+			IF (CMAKE_CL_64)
+				ADD_CUSTOM_COMMAND(
+					TARGET AppBasicDemo
+					POST_BUILD
+					COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/glut64.dll ${CMAKE_CURRENT_BINARY_DIR}
+				)
+			ELSE(CMAKE_CL_64)
+				ADD_CUSTOM_COMMAND(
+					TARGET AppBasicDemo
+					POST_BUILD
+#		  		COMMAND copy /Y ${BULLET_PHYSICS_SOURCE_DIR}/GLUT32.DLL ${CMAKE_CURRENT_BINARY_DIR}
+					COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/GLUT32.DLL ${CMAKE_CURRENT_BINARY_DIR}
+				)
+			ENDIF(CMAKE_CL_64)
+		ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+
+	ENDIF(WIN32)
+ELSE (USE_GLUT)
+
+ 
+
+	LINK_LIBRARIES(
+	OpenGLSupport  BulletDynamics  BulletCollision LinearMath  ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY}
+	)
+
+
+	ADD_EXECUTABLE(AppBasicDemo
+		WIN32
+		../OpenGL/Win32AppMain.cpp
+		Win32BasicDemo.cpp
+		BasicDemo.cpp 
+		BasicDemo.h
+		${BULLET_PHYSICS_SOURCE_DIR}/build/bullet.rc
+	)
+	
+	
+ENDIF (USE_GLUT)
+
+IF (INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)
+			SET_TARGET_PROPERTIES(AppBasicDemo PROPERTIES  DEBUG_POSTFIX "_Debug")
+			SET_TARGET_PROPERTIES(AppBasicDemo PROPERTIES  MINSIZEREL_POSTFIX "_MinsizeRel")
+			SET_TARGET_PROPERTIES(AppBasicDemo PROPERTIES  RELWITHDEBINFO_POSTFIX "_RelWithDebugInfo")
+ENDIF(INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)
\ No newline at end of file
diff --git a/Demos3/BasicDemo/Makefile.am b/Demos3/BasicDemo/Makefile.am
new file mode 100644
index 000000000..05546162b
--- /dev/null
+++ b/Demos3/BasicDemo/Makefile.am
@@ -0,0 +1,5 @@
+noinst_PROGRAMS=BasicDemo
+
+BasicDemo_SOURCES=BasicDemo.cpp BasicDemo.h main.cpp
+BasicDemo_CXXFLAGS=-I@top_builddir@/src -I@top_builddir@/Demos/OpenGL $(CXXFLAGS)
+BasicDemo_LDADD=-L../OpenGL -lbulletopenglsupport -L../../src -lBulletDynamics -lBulletCollision -lLinearMath @opengl_LIBS@
diff --git a/Demos3/BasicDemo/Win32BasicDemo.cpp b/Demos3/BasicDemo/Win32BasicDemo.cpp
new file mode 100644
index 000000000..72f92a15f
--- /dev/null
+++ b/Demos3/BasicDemo/Win32BasicDemo.cpp
@@ -0,0 +1,25 @@
+#ifdef _WINDOWS
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "BasicDemo.h"
+
+///The 'createDemo' function is called from Bullet/Demos/OpenGL/Win32AppMain.cpp to instantiate this particular demo
+DemoApplication*	createDemo()
+{
+	return new BasicDemo();
+}
+
+#endif
diff --git a/Demos3/BasicDemo/main.cpp b/Demos3/BasicDemo/main.cpp
new file mode 100644
index 000000000..d666630a8
--- /dev/null
+++ b/Demos3/BasicDemo/main.cpp
@@ -0,0 +1,39 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "BasicDemo.h"
+#include "GlutStuff.h"
+#include "btBulletDynamicsCommon.h"
+#include "LinearMath/btHashMap.h"
+
+
+	
+int main(int argc,char** argv)
+{
+
+	BasicDemo ccdDemo;
+	ccdDemo.initPhysics();
+
+
+#ifdef CHECK_MEMORY_LEAKS
+	ccdDemo.exitPhysics();
+#else
+	return glutmain(argc, argv,1024,600,"Bullet Physics Demo. http://bulletphysics.org",&ccdDemo);
+#endif
+	
+	//default glut doesn't return from mainloop
+	return 0;
+}
+
diff --git a/Demos3/BasicGpuDemo/BasicGpuDemo.cpp b/Demos3/BasicGpuDemo/BasicGpuDemo.cpp
new file mode 100644
index 000000000..9e71363ff
--- /dev/null
+++ b/Demos3/BasicGpuDemo/BasicGpuDemo.cpp
@@ -0,0 +1,357 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+///create 125 (5x5x5) dynamic object
+#define ARRAY_SIZE_X 5
+#define ARRAY_SIZE_Y 5
+#define ARRAY_SIZE_Z 5
+
+//maximum number of objects (and allow user to shoot additional boxes)
+#define MAX_PROXIES (ARRAY_SIZE_X*ARRAY_SIZE_Y*ARRAY_SIZE_Z + 1024)
+
+///scaling of the objects (0.1 = 20 centimeter boxes )
+#define SCALING 1.
+#define START_POS_X -5
+#define START_POS_Y -5
+#define START_POS_Z -3
+
+#include "BasicGpuDemo.h"
+#include "GlutStuff.h"
+///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
+#include "btBulletDynamicsCommon.h"
+#include "b3GpuDynamicsWorld.h"
+#include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h"
+
+
+
+#include "Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h"
+#include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h"
+#include "Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h"
+#include "Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h"
+#include "Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h"
+#include "Bullet3OpenCL/RigidBody/b3Config.h"
+#include "Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h"
+
+
+
+#include <stdio.h> //printf debugging
+#include "GLDebugDrawer.h"
+
+static GLDebugDrawer gDebugDraw;
+
+
+void BasicGpuDemo::clientMoveAndDisplay()
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+
+	//simple dynamics world doesn't handle fixed-time-stepping
+	float ms = getDeltaTimeMicroseconds();
+	
+	///step the simulation
+	if (m_dynamicsWorld)
+	{
+		m_dynamicsWorld->stepSimulation(ms / 1000000.f);
+		//optional but useful: debug drawing
+		m_dynamicsWorld->debugDrawWorld();
+	}
+		
+	renderme(); 
+
+	glFlush();
+
+	swapBuffers();
+
+}
+
+
+
+void BasicGpuDemo::displayCallback(void) {
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+	
+	renderme();
+
+	//optional but useful: debug drawing to detect problems
+	if (m_dynamicsWorld)
+		m_dynamicsWorld->debugDrawWorld();
+
+	glFlush();
+	swapBuffers();
+}
+
+struct btInternalData
+{
+	cl_context	m_clContext;
+	cl_device_id	m_clDevice;
+	cl_command_queue	m_clQueue;
+	const char* m_clDeviceName;
+	bool	m_clInitialized;
+
+	btInternalData()
+	{
+		m_clContext = 0;
+		m_clDevice = 0;
+		m_clQueue = 0;
+		m_clDeviceName = 0;
+		m_clInitialized =false;
+	}
+};
+
+void BasicGpuDemo::initCL(int preferredDeviceIndex, int preferredPlatformIndex)
+{
+	void* glCtx=0;
+	void* glDC = 0;
+	
+	
+    
+	int ciErrNum = 0;
+	//#ifdef CL_PLATFORM_INTEL
+	//cl_device_type deviceType = CL_DEVICE_TYPE_ALL;
+	//#else
+	cl_device_type deviceType = CL_DEVICE_TYPE_GPU;
+	//#endif
+	
+	cl_platform_id platformId;
+	
+	//	if (useInterop)
+	//	{
+	//		m_data->m_clContext = b3OpenCLUtils::createContextFromType(deviceType, &ciErrNum, glCtx, glDC);
+	//	} else
+	{
+		m_clData->m_clContext = b3OpenCLUtils::createContextFromType(deviceType, &ciErrNum, 0,0,preferredDeviceIndex, preferredPlatformIndex,&platformId);
+		b3OpenCLUtils::printPlatformInfo(platformId);
+	}
+	
+	
+	oclCHECKERROR(ciErrNum, CL_SUCCESS);
+	
+	int numDev = b3OpenCLUtils::getNumDevices(m_clData->m_clContext);
+	
+	if (numDev>0)
+	{
+		m_clData->m_clDevice= b3OpenCLUtils::getDevice(m_clData->m_clContext,0);
+		m_clData->m_clQueue = clCreateCommandQueue(m_clData->m_clContext, m_clData->m_clDevice, 0, &ciErrNum);
+		oclCHECKERROR(ciErrNum, CL_SUCCESS);
+        
+        b3OpenCLUtils::printDeviceInfo(m_clData->m_clDevice);
+		b3OpenCLDeviceInfo info;
+		b3OpenCLUtils::getDeviceInfo(m_clData->m_clDevice,&info);
+		m_clData->m_clDeviceName = info.m_deviceName;
+		m_clData->m_clInitialized = true;
+		
+	}
+	
+}
+
+void BasicGpuDemo::exitCL()
+{
+
+}
+
+BasicGpuDemo::BasicGpuDemo()
+{
+	m_clData = new btInternalData;
+}
+
+BasicGpuDemo::~BasicGpuDemo()
+{
+	exitPhysics();
+	exitCL();
+	delete m_clData;
+}
+
+
+void	BasicGpuDemo::initPhysics()
+{
+	setTexturing(true);
+	setShadows(true);
+
+	setCameraDistance(btScalar(SCALING*50.));
+
+	///collision configuration contains default setup for memory, collision setup
+	m_collisionConfiguration = 0;
+	//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+	///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+	m_dispatcher = 0;
+
+	m_broadphase = 0;
+
+	///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+	
+	m_solver = 0;
+
+	initCL(-1,-1);
+
+
+	if (!m_clData->m_clInitialized)
+	{
+		printf("Error: cannot initialize OpenCL\n");
+		exit(0);
+	}
+
+	b3Config config;
+	b3GpuNarrowPhase* np = new b3GpuNarrowPhase(m_clData->m_clContext,m_clData->m_clDevice,m_clData->m_clQueue,config);
+	b3GpuSapBroadphase* bp = new b3GpuSapBroadphase(m_clData->m_clContext,m_clData->m_clDevice,m_clData->m_clQueue);
+	//m_data->m_np = np;
+	//m_data->m_bp = bp;
+	b3DynamicBvhBroadphase* broadphaseDbvt = new b3DynamicBvhBroadphase(config.m_maxConvexBodies);
+	
+	b3GpuRigidBodyPipeline* rbp = new b3GpuRigidBodyPipeline(m_clData->m_clContext,m_clData->m_clDevice,m_clData->m_clQueue, np, bp,broadphaseDbvt);
+
+	m_dynamicsWorld = new b3GpuDynamicsWorld(bp,np,rbp);
+	
+	m_dynamicsWorld->setDebugDrawer(&gDebugDraw);
+	
+	m_dynamicsWorld->setGravity(btVector3(0,-10,0));
+
+	///create a few basic rigid bodies
+	btBoxShape* groundShape = new btBoxShape(btVector3(btScalar(50.),btScalar(50.),btScalar(50.)));
+	//groundShape->initializePolyhedralFeatures();
+//	btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0),50);
+	
+	m_collisionShapes.push_back(groundShape);
+
+	btTransform groundTransform;
+	groundTransform.setIdentity();
+	groundTransform.setOrigin(btVector3(0,-50,0));
+
+	//We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
+	{
+		btScalar mass(0.);
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0,0,0);
+		if (isDynamic)
+			groundShape->calculateLocalInertia(mass,localInertia);
+
+		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
+		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
+		btRigidBody* body = new btRigidBody(rbInfo);
+
+		//add the body to the dynamics world
+		m_dynamicsWorld->addRigidBody(body);
+	}
+
+
+	{
+		//create a few dynamic rigidbodies
+		// Re-using the same collision is better for memory usage and performance
+
+		btBoxShape* colShape = new btBoxShape(btVector3(SCALING*1,SCALING*1,SCALING*1));
+		//btCollisionShape* colShape = new btSphereShape(btScalar(1.));
+		m_collisionShapes.push_back(colShape);
+
+		/// Create Dynamic Objects
+		btTransform startTransform;
+		startTransform.setIdentity();
+
+		btScalar	mass(1.f);
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0,0,0);
+		if (isDynamic)
+			colShape->calculateLocalInertia(mass,localInertia);
+
+		float start_x = START_POS_X - ARRAY_SIZE_X/2;
+		float start_y = START_POS_Y;
+		float start_z = START_POS_Z - ARRAY_SIZE_Z/2;
+
+		for (int k=0;k<ARRAY_SIZE_Y;k++)
+		{
+			for (int i=0;i<ARRAY_SIZE_X;i++)
+			{
+				for(int j = 0;j<ARRAY_SIZE_Z;j++)
+				{
+					startTransform.setOrigin(SCALING*btVector3(
+										btScalar(2.0*i + start_x),
+										btScalar(20+2.0*k + start_y),
+										btScalar(2.0*j + start_z)));
+
+			
+					//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+					//btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+					btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,0,colShape,localInertia);
+					btRigidBody* body = new btRigidBody(rbInfo);
+					body->setWorldTransform(startTransform);
+					
+
+					m_dynamicsWorld->addRigidBody(body);
+				}
+			}
+		}
+	}
+
+	np->writeAllBodiesToGpu();
+	bp->writeAabbsToGpu();
+	rbp->writeAllInstancesToGpu();
+
+}
+void	BasicGpuDemo::clientResetScene()
+{
+	exitPhysics();
+	initPhysics();
+}
+	
+
+void	BasicGpuDemo::exitPhysics()
+{
+
+	//cleanup in the reverse order of creation/initialization
+
+	//remove the rigidbodies from the dynamics world and delete them
+	int i;
+	for (i=m_dynamicsWorld->getNumCollisionObjects()-1; i>=0 ;i--)
+	{
+		btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+		btRigidBody* body = btRigidBody::upcast(obj);
+		if (body && body->getMotionState())
+		{
+			delete body->getMotionState();
+		}
+		m_dynamicsWorld->removeCollisionObject( obj );
+		delete obj;
+	}
+
+	//delete collision shapes
+	for (int j=0;j<m_collisionShapes.size();j++)
+	{
+		btCollisionShape* shape = m_collisionShapes[j];
+		delete shape;
+	}
+	m_collisionShapes.clear();
+
+	delete m_dynamicsWorld;
+	
+	delete m_solver;
+	
+	delete m_broadphase;
+	
+	delete m_dispatcher;
+
+	delete m_collisionConfiguration;
+
+	
+}
+
+
+
+
diff --git a/Demos3/BasicGpuDemo/BasicGpuDemo.h b/Demos3/BasicGpuDemo/BasicGpuDemo.h
new file mode 100644
index 000000000..2cd950df4
--- /dev/null
+++ b/Demos3/BasicGpuDemo/BasicGpuDemo.h
@@ -0,0 +1,82 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef GPU_BASIC_DEMO_H
+#define GPU_BASIC_DEMO_H
+
+#ifdef _WINDOWS
+#include "Win32DemoApplication.h"
+#define PlatformDemoApplication Win32DemoApplication
+#else
+#include "GlutDemoApplication.h"
+#define PlatformDemoApplication GlutDemoApplication
+#endif
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+class btBroadphaseInterface;
+class btCollisionShape;
+class btOverlappingPairCache;
+class btCollisionDispatcher;
+class btConstraintSolver;
+struct btCollisionAlgorithmCreateFunc;
+class btDefaultCollisionConfiguration;
+
+
+class BasicGpuDemo : public PlatformDemoApplication
+{
+
+	//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
+
+	btBroadphaseInterface*	m_broadphase;
+
+	btCollisionDispatcher*	m_dispatcher;
+
+	btConstraintSolver*	m_solver;
+
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+
+	struct btInternalData*	m_clData;
+
+	void	initCL(int d, int p);
+	void	exitCL();
+
+	public:
+
+	BasicGpuDemo();
+	virtual ~BasicGpuDemo();
+
+	void	initPhysics();
+
+	void	exitPhysics();
+
+	virtual void clientMoveAndDisplay();
+
+	virtual void displayCallback();
+	virtual void	clientResetScene();
+	
+	static DemoApplication* Create()
+	{
+		BasicGpuDemo* demo = new BasicGpuDemo;
+		demo->myinit();
+		demo->initPhysics();
+		return demo;
+	}
+
+	
+};
+
+#endif //GPU_BASIC_DEMO_H
+
diff --git a/Demos3/BasicGpuDemo/CMakeLists.txt b/Demos3/BasicGpuDemo/CMakeLists.txt
new file mode 100644
index 000000000..253b8b47c
--- /dev/null
+++ b/Demos3/BasicGpuDemo/CMakeLists.txt
@@ -0,0 +1,87 @@
+# This is basically the overall name of the project in Visual Studio this is the name of the Solution File
+
+
+# For every executable you have with a main method you should have an add_executable line below.
+# For every add executable line you should list every .cpp and .h file you have associated with that executable.  
+
+
+# This is the variable for Windows.  I use this to define the root of my directory structure.
+SET(GLUT_ROOT ${BULLET_PHYSICS_SOURCE_DIR}/Glut)
+
+# You shouldn't have to modify anything below this line 
+########################################################
+
+INCLUDE_DIRECTORIES(
+${BULLET_PHYSICS_SOURCE_DIR}/src ${BULLET_PHYSICS_SOURCE_DIR}/Demos/OpenGL 
+)
+
+
+
+IF (USE_GLUT)
+	LINK_LIBRARIES(
+	OpenGLSupport  BulletDynamics  BulletCollision LinearMath  ${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY}
+	)
+
+IF (WIN32)
+ADD_EXECUTABLE(AppBasicDemo
+		main.cpp
+		BasicDemo.cpp 
+		BasicDemo.h
+		${BULLET_PHYSICS_SOURCE_DIR}/build/bullet.rc
+	)
+ELSE()
+	ADD_EXECUTABLE(AppBasicDemo
+		main.cpp
+		BasicDemo.cpp 
+		BasicDemo.h
+	)
+ENDIF()
+
+
+
+
+	IF (WIN32)
+		IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+			IF (CMAKE_CL_64)
+				ADD_CUSTOM_COMMAND(
+					TARGET AppBasicDemo
+					POST_BUILD
+					COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/glut64.dll ${CMAKE_CURRENT_BINARY_DIR}
+				)
+			ELSE(CMAKE_CL_64)
+				ADD_CUSTOM_COMMAND(
+					TARGET AppBasicDemo
+					POST_BUILD
+#		  		COMMAND copy /Y ${BULLET_PHYSICS_SOURCE_DIR}/GLUT32.DLL ${CMAKE_CURRENT_BINARY_DIR}
+					COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/GLUT32.DLL ${CMAKE_CURRENT_BINARY_DIR}
+				)
+			ENDIF(CMAKE_CL_64)
+		ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+
+	ENDIF(WIN32)
+ELSE (USE_GLUT)
+
+ 
+
+	LINK_LIBRARIES(
+	OpenGLSupport  BulletDynamics  BulletCollision LinearMath  ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY}
+	)
+
+
+	ADD_EXECUTABLE(AppBasicDemo
+		WIN32
+		../OpenGL/Win32AppMain.cpp
+		Win32BasicDemo.cpp
+		BasicDemo.cpp 
+		BasicDemo.h
+		${BULLET_PHYSICS_SOURCE_DIR}/build/bullet.rc
+	)
+	
+	
+ENDIF (USE_GLUT)
+
+IF (INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)
+			SET_TARGET_PROPERTIES(AppBasicDemo PROPERTIES  DEBUG_POSTFIX "_Debug")
+			SET_TARGET_PROPERTIES(AppBasicDemo PROPERTIES  MINSIZEREL_POSTFIX "_MinsizeRel")
+			SET_TARGET_PROPERTIES(AppBasicDemo PROPERTIES  RELWITHDEBINFO_POSTFIX "_RelWithDebugInfo")
+ENDIF(INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)
\ No newline at end of file
diff --git a/Demos3/BasicGpuDemo/Makefile.am b/Demos3/BasicGpuDemo/Makefile.am
new file mode 100644
index 000000000..05546162b
--- /dev/null
+++ b/Demos3/BasicGpuDemo/Makefile.am
@@ -0,0 +1,5 @@
+noinst_PROGRAMS=BasicDemo
+
+BasicDemo_SOURCES=BasicDemo.cpp BasicDemo.h main.cpp
+BasicDemo_CXXFLAGS=-I@top_builddir@/src -I@top_builddir@/Demos/OpenGL $(CXXFLAGS)
+BasicDemo_LDADD=-L../OpenGL -lbulletopenglsupport -L../../src -lBulletDynamics -lBulletCollision -lLinearMath @opengl_LIBS@
diff --git a/Demos3/BasicGpuDemo/Win32BasicDemo.cpp b/Demos3/BasicGpuDemo/Win32BasicDemo.cpp
new file mode 100644
index 000000000..72f92a15f
--- /dev/null
+++ b/Demos3/BasicGpuDemo/Win32BasicDemo.cpp
@@ -0,0 +1,25 @@
+#ifdef _WINDOWS
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "BasicDemo.h"
+
+///The 'createDemo' function is called from Bullet/Demos/OpenGL/Win32AppMain.cpp to instantiate this particular demo
+DemoApplication*	createDemo()
+{
+	return new BasicDemo();
+}
+
+#endif
diff --git a/Demos3/BasicGpuDemo/main.cpp b/Demos3/BasicGpuDemo/main.cpp
new file mode 100644
index 000000000..7559a36a7
--- /dev/null
+++ b/Demos3/BasicGpuDemo/main.cpp
@@ -0,0 +1,39 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "BasicGpuDemo.h"
+#include "GlutStuff.h"
+#include "btBulletDynamicsCommon.h"
+#include "LinearMath/btHashMap.h"
+
+
+	
+int main(int argc,char** argv)
+{
+
+	BasicGpuDemo ccdDemo;
+	ccdDemo.initPhysics();
+
+
+#ifdef CHECK_MEMORY_LEAKS
+	ccdDemo.exitPhysics();
+#else
+	return glutmain(argc, argv,1024,600,"Bullet Physics Demo. http://bulletphysics.org",&ccdDemo);
+#endif
+	
+	//default glut doesn't return from mainloop
+	return 0;
+}
+
diff --git a/Demos3/GpuDemos/rigidbody/GpuRigidBodyDemo.cpp b/Demos3/GpuDemos/rigidbody/GpuRigidBodyDemo.cpp
index 1e70f4c9f..e052cfa05 100644
--- a/Demos3/GpuDemos/rigidbody/GpuRigidBodyDemo.cpp
+++ b/Demos3/GpuDemos/rigidbody/GpuRigidBodyDemo.cpp
@@ -121,6 +121,7 @@ void	GpuRigidBodyDemo::initPhysics(const ConstructionInfo& ci)
 
 		np->writeAllBodiesToGpu();
 		bp->writeAabbsToGpu();
+
 	}
 
 
diff --git a/build/premake4.lua b/build/premake4.lua
index fe7e6daaf..3e5862595 100644
--- a/build/premake4.lua
+++ b/build/premake4.lua
@@ -19,6 +19,11 @@
     		description = "Enable iOS target (requires xcode4)"
   	}
 	
+	newoption
+	{
+		trigger = "bullet2gpu",
+		description = "Enable Bullet 2.x GPU using b3GpuDynamicsWorld bridge to Bullet 3.x"
+	}
   
 	configurations {"Release", "Debug"}
 	configuration "Release"
@@ -124,4 +129,17 @@
 		
 --		include "../test/b3DynamicBvhBroadphase"
 		
+
+	
+
+	if _OPTIONS["bullet2gpu"] then
+		include "../src/LinearMath"	
+	include "../src/BulletCollision"	
+	include "../src/BulletDynamics"	
+	include "../src/BulletSoftBody"		
+	include "../Demos/HelloWorld"
+	
+		include "../Demos3"
 	end
+
+		end
diff --git a/build/vs2010_bullet2gpu.bat b/build/vs2010_bullet2gpu.bat
new file mode 100644
index 000000000..48fa4b7f4
--- /dev/null
+++ b/build/vs2010_bullet2gpu.bat
@@ -0,0 +1,6 @@
+
+rem premake4 --with-pe  vs2010
+premake4  --bullet2gpu vs2010 
+
+mkdir vs2010\cache
+pause
\ No newline at end of file
diff --git a/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp
new file mode 100644
index 000000000..14e0de17f
--- /dev/null
+++ b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.cpp
@@ -0,0 +1,299 @@
+#include "b3GpuDynamicsWorld.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
+//#include "../../../opencl/gpu_rigidbody_pipeline2/CLPhysicsDemo.h"
+//#include "../../../opencl/gpu_rigidbody_pipeline/b3GpuNarrowPhaseAndSolver.h"
+#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h"
+#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
+
+#include "LinearMath/btQuickprof.h"
+#include "Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h"
+#include "Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h"
+
+
+#ifdef _WIN32
+	#include <wiNdOws.h>
+#endif
+
+
+
+b3GpuDynamicsWorld::b3GpuDynamicsWorld(class b3GpuSapBroadphase* bp,class b3GpuNarrowPhase* np, class b3GpuRigidBodyPipeline* rigidBodyPipeline)
+	:btDynamicsWorld(0,0,0),
+	m_gravity(0,-10,0),
+m_once(true),
+m_bp(bp),
+m_np(np),
+m_rigidBodyPipeline(rigidBodyPipeline)
+{
+
+}
+
+b3GpuDynamicsWorld::~b3GpuDynamicsWorld()
+{
+	
+}
+
+
+
+
+int		b3GpuDynamicsWorld::stepSimulation( btScalar timeStep,int maxSubSteps, btScalar fixedTimeStep)
+{
+#ifndef BT_NO_PROFILE
+	CProfileManager::Reset();
+#endif //BT_NO_PROFILE
+
+
+	BT_PROFILE("stepSimulation");
+
+	//convert all shapes now, and if any change, reset all (todo)
+	
+	if (m_once)
+	{
+		m_once = false;
+		m_rigidBodyPipeline->writeAllInstancesToGpu();
+	}
+
+	m_rigidBodyPipeline->stepSimulation(fixedTimeStep);
+
+	{
+		{
+			BT_PROFILE("readbackBodiesToCpu");
+			//now copy info back to rigid bodies....
+			m_np->readbackAllBodiesToCpu();
+		}
+
+		
+		{
+			BT_PROFILE("scatter transforms into rigidbody (CPU)");
+			for (int i=0;i<this->m_collisionObjects.size();i++)
+			{
+				btVector3 pos;
+				btQuaternion orn;
+				m_np->getObjectTransformFromCpu(&pos[0],&orn[0],i);
+				btTransform newTrans;
+				newTrans.setOrigin(pos);
+				newTrans.setRotation(orn);
+				this->m_collisionObjects[i]->setWorldTransform(newTrans);
+			}
+		}
+	}
+
+
+#ifndef B3_NO_PROFILE
+	CProfileManager::Increment_Frame_Counter();
+#endif //B3_NO_PROFILE
+
+
+
+	return 1;
+}
+
+
+void	b3GpuDynamicsWorld::setGravity(const btVector3& gravity)
+{
+}
+
+int b3GpuDynamicsWorld::findOrRegisterCollisionShape(const btCollisionShape* colShape)
+{
+	int index = m_uniqueShapes.findLinearSearch(colShape);
+	if (index==m_uniqueShapes.size())
+	{
+		if (colShape->isPolyhedral())
+		{
+			m_uniqueShapes.push_back(colShape);
+			
+			btPolyhedralConvexShape* convex = (btPolyhedralConvexShape*)colShape;
+			int numVertices=convex->getNumVertices();
+			
+			int strideInBytes=sizeof(btVector3);
+			btAlignedObjectArray<btVector3> tmpVertices;
+			tmpVertices.resize(numVertices);
+			for (int i=0;i<numVertices;i++)
+				convex->getVertex(i,tmpVertices[i]);
+			const float scaling[4]={1,1,1,1};
+			bool noHeightField=true;
+			
+			int gpuShapeIndex = m_np->registerConvexHullShape(&tmpVertices[0].getX(), strideInBytes, numVertices, scaling);
+			m_uniqueShapeMapping.push_back(gpuShapeIndex);
+		} else
+		{
+			if (colShape->getShapeType()==TRIANGLE_MESH_SHAPE_PROXYTYPE)
+			{
+				m_uniqueShapes.push_back(colShape);
+				
+				btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*) colShape;
+				btStridingMeshInterface* meshInterface = trimesh->getMeshInterface();
+				b3AlignedObjectArray<b3Vector3> vertices;
+				b3AlignedObjectArray<int> indices;
+				
+				btVector3 trimeshScaling(1,1,1);
+				for (int partId=0;partId<meshInterface->getNumSubParts();partId++)
+				{
+					
+					const unsigned char *vertexbase = 0;
+					int numverts = 0;
+					PHY_ScalarType type = PHY_INTEGER;
+					int stride = 0;
+					const unsigned char *indexbase = 0;
+					int indexstride = 0;
+					int numfaces = 0;
+					PHY_ScalarType indicestype = PHY_INTEGER;
+					//PHY_ScalarType indexType=0;
+					
+					b3Vector3 triangleVerts[3];
+					meshInterface->getLockedReadOnlyVertexIndexBase(&vertexbase,numverts,	type,stride,&indexbase,indexstride,numfaces,indicestype,partId);
+					btVector3 aabbMin,aabbMax;
+					
+					for (int triangleIndex = 0 ; triangleIndex < numfaces;triangleIndex++)
+					{
+						unsigned int* gfxbase = (unsigned int*)(indexbase+triangleIndex*indexstride);
+						
+						for (int j=2;j>=0;j--)
+						{
+							
+							int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
+							if (type == PHY_FLOAT)
+							{
+								float* graphicsbase = (float*)(vertexbase+graphicsindex*stride);
+								triangleVerts[j] = b3Vector3(
+															 graphicsbase[0]*trimeshScaling.getX(),
+															 graphicsbase[1]*trimeshScaling.getY(),
+															 graphicsbase[2]*trimeshScaling.getZ());
+							}
+							else
+							{
+								double* graphicsbase = (double*)(vertexbase+graphicsindex*stride);
+								triangleVerts[j] = b3Vector3( btScalar(graphicsbase[0]*trimeshScaling.getX()),
+															 btScalar(graphicsbase[1]*trimeshScaling.getY()),
+															 btScalar(graphicsbase[2]*trimeshScaling.getZ()));
+							}
+						}
+						vertices.push_back(triangleVerts[0]);
+						vertices.push_back(triangleVerts[1]);
+						vertices.push_back(triangleVerts[2]);
+						indices.push_back(indices.size());
+						indices.push_back(indices.size());
+						indices.push_back(indices.size());
+					}
+				}
+				//GraphicsShape* gfxShape = 0;//b3BulletDataExtractor::createGraphicsShapeFromWavefrontObj(objData);
+				
+				//GraphicsShape* gfxShape = b3BulletDataExtractor::createGraphicsShapeFromConvexHull(&sUnitSpherePoints[0],MY_UNITSPHERE_POINTS);
+				float meshScaling[4] = {1,1,1,1};
+				//int shapeIndex = renderer.registerShape(gfxShape->m_vertices,gfxShape->m_numvertices,gfxShape->m_indices,gfxShape->m_numIndices);
+				float groundPos[4] = {0,0,0,0};
+				
+				//renderer.registerGraphicsInstance(shapeIndex,groundPos,rotOrn,color,meshScaling);
+				if (vertices.size() && indices.size())
+				{
+					int gpuShapeIndex = m_np->registerConcaveMesh(&vertices,&indices, meshScaling);
+					m_uniqueShapeMapping.push_back(gpuShapeIndex);
+				} else
+				{
+					printf("Error: no vertices in mesh in b3GpuDynamicsWorld::addRigidBody\n");
+					index = -1;
+					b3Assert(0);
+				}
+				
+				
+			} else
+			{
+				if (colShape->getShapeType()==COMPOUND_SHAPE_PROXYTYPE)
+				{
+					
+					btCompoundShape* compound = (btCompoundShape*) colShape;
+					b3AlignedObjectArray<b3GpuChildShape> childShapes;
+					
+					for (int i=0;i<compound->getNumChildShapes();i++)
+					{
+						//for now, only support polyhedral child shapes
+						b3Assert(compound->getChildShape(i)->isPolyhedral());
+						b3GpuChildShape child;
+						child.m_shapeIndex = findOrRegisterCollisionShape(compound->getChildShape(i));
+						btVector3 pos = compound->getChildTransform(i).getOrigin();
+						btQuaternion orn = compound->getChildTransform(i).getRotation();
+						for (int v=0;v<4;v++)
+						{
+							child.m_childPosition[v] = pos[v];
+							child.m_childOrientation[v] = orn[v];
+						}
+						childShapes.push_back(child);
+					}
+					index = m_uniqueShapes.size();
+					m_uniqueShapes.push_back(colShape);
+					
+					int gpuShapeIndex = m_np->registerCompoundShape(&childShapes);
+					m_uniqueShapeMapping.push_back(gpuShapeIndex);
+
+					
+					
+					
+					/*printf("Error: unsupported compound type (%d) in b3GpuDynamicsWorld::addRigidBody\n",colShape->getShapeType());
+					index = -1;
+					b3Assert(0);
+					 */
+				} else
+				{
+					if (colShape->getShapeType()==SPHERE_SHAPE_PROXYTYPE)
+					{
+						m_uniqueShapes.push_back(colShape);
+						btSphereShape* sphere = (btSphereShape*)colShape;
+						
+						int gpuShapeIndex = m_np->registerSphereShape(sphere->getRadius());
+						m_uniqueShapeMapping.push_back(gpuShapeIndex);
+					} else
+					{
+						if (colShape->getShapeType()==STATIC_PLANE_PROXYTYPE)
+						{
+							m_uniqueShapes.push_back(colShape);
+							btStaticPlaneShape* plane = (btStaticPlaneShape*)colShape;
+						
+							int gpuShapeIndex = m_np->registerPlaneShape((b3Vector3&)plane->getPlaneNormal(),plane->getPlaneConstant());
+							m_uniqueShapeMapping.push_back(gpuShapeIndex);
+						} else
+						{
+							printf("Error: unsupported shape type (%d) in b3GpuDynamicsWorld::addRigidBody\n",colShape->getShapeType());
+							index = -1;
+							b3Assert(0);
+						}
+					}
+				}
+			}
+		}
+		
+	}
+	
+	return index;
+}
+
+void	b3GpuDynamicsWorld::addRigidBody(btRigidBody* body)
+{
+
+	body->setMotionState(0);
+	
+
+	int index = findOrRegisterCollisionShape(body->getCollisionShape());
+
+	if (index>=0)
+	{
+		int gpuShapeIndex= m_uniqueShapeMapping[index];
+		float mass = body->getInvMass() ? 1.f/body->getInvMass() : 0.f;
+		btVector3 pos = body->getWorldTransform().getOrigin();
+		btQuaternion orn = body->getWorldTransform().getRotation();
+	
+		m_rigidBodyPipeline->registerPhysicsInstance(mass,&pos.getX(),&orn.getX(),gpuShapeIndex,m_collisionObjects.size(),false);
+
+		m_collisionObjects.push_back(body);
+		//btDynamicsWorld::addCollisionObject(
+	}
+}
+
+void	b3GpuDynamicsWorld::removeCollisionObject(btCollisionObject* colObj)
+{
+	btDynamicsWorld::removeCollisionObject(colObj);
+}
+
+
diff --git a/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h
new file mode 100644
index 000000000..3d4f525bd
--- /dev/null
+++ b/demos3/BasicGpuDemo/b3GpuDynamicsWorld.h
@@ -0,0 +1,113 @@
+#ifndef B3_GPU_DYNAMICS_WORLD_H
+#define B3_GPU_DYNAMICS_WORLD_H
+
+#include "LinearMath/btVector3.h"
+
+class btRigidBody;
+class btCollisionObject;
+struct b3GpuInternalData;//use this struct to avoid 'leaking' all OpenCL headers into clients code base
+class CLPhysicsDemo;
+class btActionInterface;
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "BulletDynamics/Dynamics/btDynamicsWorld.h"
+
+
+class b3GpuDynamicsWorld : public btDynamicsWorld
+{
+	
+	btAlignedObjectArray<const class  btCollisionShape*> m_uniqueShapes;
+	btAlignedObjectArray<int> m_uniqueShapeMapping;
+
+
+	class b3GpuRigidBodyPipeline* m_rigidBodyPipeline;
+	class b3GpuNarrowPhase* m_np;
+	class b3GpuSapBroadphase* m_bp;
+
+	
+	btVector3			m_gravity;
+	bool	m_once;
+	
+		
+	int findOrRegisterCollisionShape(const btCollisionShape* colShape);
+
+	
+public:
+	b3GpuDynamicsWorld(class b3GpuSapBroadphase* bp,class b3GpuNarrowPhase* np, class b3GpuRigidBodyPipeline* rigidBodyPipeline);
+
+	virtual ~b3GpuDynamicsWorld();
+
+	virtual int		stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
+
+	virtual void	synchronizeMotionStates()
+	{
+		btAssert(0);
+	}
+
+	void	debugDrawWorld() {}
+
+	void	setGravity(const btVector3& gravity);
+
+	void	addRigidBody(btRigidBody* body);
+
+	void	removeCollisionObject(btCollisionObject* colObj);
+
+	
+
+	btAlignedObjectArray<class btCollisionObject*>& getCollisionObjectArray();
+
+	const btAlignedObjectArray<class btCollisionObject*>& getCollisionObjectArray() const;
+
+
+	btVector3 getGravity () const
+	{
+		return m_gravity;
+	}
+
+		virtual void	addRigidBody(btRigidBody* body, short group, short mask)
+		{
+			addRigidBody(body);
+		}
+
+		virtual void	removeRigidBody(btRigidBody* body)
+		{
+			btAssert(0);
+		}
+
+
+		virtual void	addAction(btActionInterface* action) 
+		{
+			btAssert(0);
+		}
+
+		virtual void	removeAction(btActionInterface* action)
+		{
+			btAssert(0);
+		}
+
+		virtual void	setConstraintSolver(btConstraintSolver* solver)
+		{
+			btAssert(0);
+		}
+
+		virtual btConstraintSolver* getConstraintSolver()
+		{
+			btAssert(0);
+			return 0;
+		}
+		
+
+		virtual void	clearForces()
+		{
+			btAssert(0);
+		}
+
+		virtual btDynamicsWorldType	getWorldType() const
+		{
+			return BT_GPU_DYNAMICS_WORLD;
+		}
+
+};
+
+
+#endif //B3_GPU_DYNAMICS_WORLD_H
diff --git a/src/Bullet3Common/b3Matrix3x3.h b/src/Bullet3Common/b3Matrix3x3.h
index d15e1d279..98d699f02 100644
--- a/src/Bullet3Common/b3Matrix3x3.h
+++ b/src/Bullet3Common/b3Matrix3x3.h
@@ -21,14 +21,14 @@ subject to the following restrictions:
 #include <stdio.h>
 
 #ifdef B3_USE_SSE
-//const __m128 B3_ATTRIBUTE_ALIGNED16(v2220) = {2.0f, 2.0f, 2.0f, 0.0f};
-const __m128 B3_ATTRIBUTE_ALIGNED16(vMPPP) = {-0.0f, +0.0f, +0.0f, +0.0f};
+//const __m128 B3_ATTRIBUTE_ALIGNED16(b3v2220) = {2.0f, 2.0f, 2.0f, 0.0f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vMPPP) = {-0.0f, +0.0f, +0.0f, +0.0f};
 #endif
 
 #if defined(B3_USE_SSE) || defined(B3_USE_NEON)
-const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(v1000) = {1.0f, 0.0f, 0.0f, 0.0f};
-const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(v0100) = {0.0f, 1.0f, 0.0f, 0.0f};
-const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(v0010) = {0.0f, 0.0f, 1.0f, 0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3v1000) = {1.0f, 0.0f, 0.0f, 0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3v0100) = {0.0f, 1.0f, 0.0f, 0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3v0010) = {0.0f, 0.0f, 1.0f, 0.0f};
 #endif
 
 #ifdef B3_USE_DOUBLE_PRECISION
@@ -219,7 +219,7 @@ public:
         V1 = b3CastiTo128f(_mm_shuffle_epi32 (Qi, B3_SHUFFLE(1,0,2,3)));	// Y X Z W
 		V2 = _mm_shuffle_ps(NQ, Q, B3_SHUFFLE(0,0,1,3));     // -X -X  Y  W
         V3 = b3CastiTo128f(_mm_shuffle_epi32 (Qi, B3_SHUFFLE(2,1,0,3)));	// Z Y X W
-        V1 = _mm_xor_ps(V1, vMPPP);	//	change the sign of the first element
+        V1 = _mm_xor_ps(V1, b3vMPPP);	//	change the sign of the first element
 			
         V11	= b3CastiTo128f(_mm_shuffle_epi32 (Qi, B3_SHUFFLE(1,1,0,3)));	// Y Y X W
 		V21 = _mm_unpackhi_ps(Q, Q);                    //  Z  Z  W  W
@@ -231,9 +231,9 @@ public:
 
         V11 = _mm_shuffle_ps(NQ, Q, B3_SHUFFLE(2,3,1,3));	//	-Z -W  Y  W
 		V11 = V11 * V21;	//
-        V21 = _mm_xor_ps(V21, vMPPP);	//	change the sign of the first element
+        V21 = _mm_xor_ps(V21, b3vMPPP);	//	change the sign of the first element
 		V31 = _mm_shuffle_ps(Q, NQ, B3_SHUFFLE(3,3,1,3));	//	 W  W -Y -W
-        V31 = _mm_xor_ps(V31, vMPPP);	//	change the sign of the first element
+        V31 = _mm_xor_ps(V31, b3vMPPP);	//	change the sign of the first element
 		Y = b3CastiTo128f(_mm_shuffle_epi32 (NQi, B3_SHUFFLE(3,2,0,3)));	// -W -Z -X -W
 		Z = b3CastiTo128f(_mm_shuffle_epi32 (Qi, B3_SHUFFLE(1,0,1,3)));	//  Y  X  Y  W
 
@@ -251,9 +251,9 @@ public:
         V2 = V2 * vs;
         V3 = V3 * vs;
         
-        V1 = V1 + v1000;
-        V2 = V2 + v0100;
-        V3 = V3 + v0010;
+        V1 = V1 + b3v1000;
+        V2 = V2 + b3v0100;
+        V3 = V3 + b3v0010;
         
         m_el[0] = V1; 
         m_el[1] = V2;
@@ -312,9 +312,9 @@ public:
 	void setIdentity()
 	{ 
 #if (defined(B3_USE_SSE_IN_API)&& defined (B3_USE_SSE)) || defined(B3_USE_NEON)
-			m_el[0] = v1000; 
-			m_el[1] = v0100;
-			m_el[2] = v0010;
+			m_el[0] = b3v1000; 
+			m_el[1] = b3v0100;
+			m_el[2] = b3v0010;
 #else
 		setValue(b3Scalar(1.0), b3Scalar(0.0), b3Scalar(0.0), 
 			b3Scalar(0.0), b3Scalar(1.0), b3Scalar(0.0), 
@@ -326,7 +326,7 @@ public:
 	{
 #if (defined(B3_USE_SSE_IN_API)&& defined (B3_USE_SSE)) || defined(B3_USE_NEON)
         static const b3Matrix3x3 
-        identityMatrix(v1000, v0100, v0010);
+        identityMatrix(b3v1000, b3v0100, b3v0010);
 #else
 		static const b3Matrix3x3 
         identityMatrix(
diff --git a/src/Bullet3Common/b3QuadWord.h b/src/Bullet3Common/b3QuadWord.h
index 7dda971cc..f135db676 100644
--- a/src/Bullet3Common/b3QuadWord.h
+++ b/src/Bullet3Common/b3QuadWord.h
@@ -52,6 +52,7 @@ public:
 #else //__CELLOS_LV2__ __SPU__
 
 #if defined(B3_USE_SSE) || defined(B3_USE_NEON) 
+public:
 	union {
 		b3SimdFloat4 mVec128;
 		b3Scalar	m_floats[4];
diff --git a/src/Bullet3Common/b3Quaternion.h b/src/Bullet3Common/b3Quaternion.h
index f5f38993f..1464e42e2 100644
--- a/src/Bullet3Common/b3Quaternion.h
+++ b/src/Bullet3Common/b3Quaternion.h
@@ -27,14 +27,14 @@ subject to the following restrictions:
 
 #ifdef B3_USE_SSE
 
-const __m128 B3_ATTRIBUTE_ALIGNED16(vOnes) = {1.0f, 1.0f, 1.0f, 1.0f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vOnes) = {1.0f, 1.0f, 1.0f, 1.0f};
 
 #endif
 
 #if defined(B3_USE_SSE) || defined(B3_USE_NEON)
 
-const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(vQInv) = {-0.0f, -0.0f, -0.0f, +0.0f};
-const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(vPPPM) = {+0.0f, +0.0f, +0.0f, -0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3vQInv) = {-0.0f, -0.0f, -0.0f, +0.0f};
+const b3SimdFloat4 B3_ATTRIBUTE_ALIGNED16(b3vPPPM) = {+0.0f, +0.0f, +0.0f, -0.0f};
 
 #endif
 
@@ -227,7 +227,7 @@ public:
 		
 		A1 = A1 + A2;	//	AB12
 		mVec128 = mVec128 - B1;	//	AB03 = AB0 - AB3 
-		A1 = _mm_xor_ps(A1, vPPPM);	//	change sign of the last element
+		A1 = _mm_xor_ps(A1, b3vPPPM);	//	change sign of the last element
 		mVec128 = mVec128+ A1;	//	AB03 + AB12
 
 #elif defined(B3_USE_NEON)     
@@ -270,7 +270,7 @@ public:
         A0 = vsubq_f32(A0, A3);	//	AB03 = AB0 - AB3 
         
         //	change the sign of the last element
-        A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);	
+        A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);	
         A0 = vaddq_f32(A0, A1);	//	AB03 + AB12
         
         mVec128 = A0;
@@ -338,7 +338,7 @@ public:
 		vd = _mm_add_ss(vd, t);
 
 		vd = _mm_sqrt_ss(vd);
-		vd = _mm_div_ss(vOnes, vd);
+		vd = _mm_div_ss(b3vOnes, vd);
         vd = b3_pshufd_ps(vd, 0); // splat
 		mVec128 = _mm_mul_ps(mVec128, vd);
     
@@ -416,9 +416,9 @@ public:
 	b3Quaternion inverse() const
 	{
 #if defined (B3_USE_SSE_IN_API) && defined (B3_USE_SSE)
-		return b3Quaternion(_mm_xor_ps(mVec128, vQInv));
+		return b3Quaternion(_mm_xor_ps(mVec128, b3vQInv));
 #elif defined(B3_USE_NEON)
-        return b3Quaternion((b3SimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)vQInv));
+        return b3Quaternion((b3SimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)b3vQInv));
 #else	
 		return b3Quaternion(-m_floats[0], -m_floats[1], -m_floats[2], m_floats[3]);
 #endif
@@ -567,7 +567,7 @@ operator*(const b3Quaternion& q1, const b3Quaternion& q2)
 	A1 = A1 + A2;	//	AB12
 	A0 =  A0 - B1;	//	AB03 = AB0 - AB3 
 	
-    A1 = _mm_xor_ps(A1, vPPPM);	//	change sign of the last element
+    A1 = _mm_xor_ps(A1, b3vPPPM);	//	change sign of the last element
 	A0 = A0 + A1;	//	AB03 + AB12
 	
 	return b3Quaternion(A0);
@@ -612,7 +612,7 @@ operator*(const b3Quaternion& q1, const b3Quaternion& q2)
 	A0 = vsubq_f32(A0, A3);	//	AB03 = AB0 - AB3 
 	
     //	change the sign of the last element
-    A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);	
+    A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);	
 	A0 = vaddq_f32(A0, A1);	//	AB03 + AB12
 	
 	return b3Quaternion(A0);
@@ -650,7 +650,7 @@ operator*(const b3Quaternion& q, const b3Vector3& w)
 	A3 = A3 * B3;	//	A3 *= B3
 
 	A1 = A1 + A2;	//	AB12
-	A1 = _mm_xor_ps(A1, vPPPM);	//	change sign of the last element
+	A1 = _mm_xor_ps(A1, b3vPPPM);	//	change sign of the last element
     A1 = A1 - A3;	//	AB123 = AB12 - AB3 
 	
 	return b3Quaternion(A1);
@@ -694,7 +694,7 @@ operator*(const b3Quaternion& q, const b3Vector3& w)
 	A1 = vaddq_f32(A1, A2);	//	AB12 = AB1 + AB2
 	
     //	change the sign of the last element
-    A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);	
+    A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);	
 	
     A1 = vsubq_f32(A1, A3);	//	AB123 = AB12 - AB3
 	
@@ -733,7 +733,7 @@ operator*(const b3Vector3& w, const b3Quaternion& q)
 	A3 = A3 * B3;	//	A3 *= B3
 
 	A1 = A1 + A2;	//	AB12
-	A1 = _mm_xor_ps(A1, vPPPM);	//	change sign of the last element
+	A1 = _mm_xor_ps(A1, b3vPPPM);	//	change sign of the last element
 	A1 = A1 - A3;	//	AB123 = AB12 - AB3 
 	
 	return b3Quaternion(A1);
@@ -777,7 +777,7 @@ operator*(const b3Vector3& w, const b3Quaternion& q)
 	A1 = vaddq_f32(A1, A2);	//	AB12 = AB1 + AB2
 	
     //	change the sign of the last element
-    A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM);	
+    A1 = (b3SimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)b3vPPPM);	
 	
     A1 = vsubq_f32(A1, A3);	//	AB123 = AB12 - AB3
 	
diff --git a/src/Bullet3Common/b3Scalar.h b/src/Bullet3Common/b3Scalar.h
index eae7adcbd..67c65aaa1 100644
--- a/src/Bullet3Common/b3Scalar.h
+++ b/src/Bullet3Common/b3Scalar.h
@@ -272,9 +272,9 @@ static int b3NanMask = 0x7F800001;
 #define B3_NAN (*(float*)&b3NanMask)
 #endif
 
-#ifndef B3_INFINITY
+#ifndef B3_INFINITY_MASK
 static  int b3InfinityMask = 0x7F800000;
-#define B3_INFINITY (*(float*)&b3InfinityMask)
+#define B3_INFINITY_MASK (*(float*)&b3InfinityMask)
 #endif
 
 inline __m128 operator + (const __m128 A, const __m128 B)
diff --git a/src/Bullet3Common/b3Vector3.h b/src/Bullet3Common/b3Vector3.h
index e8f6350b9..df0d96013 100644
--- a/src/Bullet3Common/b3Vector3.h
+++ b/src/Bullet3Common/b3Vector3.h
@@ -56,9 +56,9 @@ subject to the following restrictions:
 
 
 const __m128 B3_ATTRIBUTE_ALIGNED16(b3vMzeroMask) = {-0.0f, -0.0f, -0.0f, -0.0f};
-const __m128 B3_ATTRIBUTE_ALIGNED16(v1110) = {1.0f, 1.0f, 1.0f, 0.0f};
-const __m128 B3_ATTRIBUTE_ALIGNED16(vHalf) = {0.5f, 0.5f, 0.5f, 0.5f};
-const __m128 B3_ATTRIBUTE_ALIGNED16(v1_5)  = {1.5f, 1.5f, 1.5f, 1.5f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3v1110) = {1.0f, 1.0f, 1.0f, 0.0f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3vHalf) = {0.5f, 0.5f, 0.5f, 0.5f};
+const __m128 B3_ATTRIBUTE_ALIGNED16(b3v1_5)  = {1.5f, 1.5f, 1.5f, 1.5f};
 
 #endif
 
@@ -216,7 +216,7 @@ public:
 #if 0 //defined(B3_USE_SSE_IN_API)
 // this code is not faster !
 		__m128 vs = _mm_load_ss(&s);
-		vs = _mm_div_ss(v1110, vs);
+		vs = _mm_div_ss(b3v1110, vs);
 		vs = b3_pshufd_ps(vs, 0x00);	//	(S S S S)
 
 		mVec128 = _mm_mul_ps(mVec128, vs);
@@ -297,7 +297,7 @@ public:
 		
         #if 0
         vd = _mm_sqrt_ss(vd);
-		vd = _mm_div_ss(v1110, vd);
+		vd = _mm_div_ss(b3v1110, vd);
 		vd = b3_splat_ps(vd, 0x80);
 		mVec128 = _mm_mul_ps(mVec128, vd);
         #else
@@ -306,8 +306,8 @@ public:
         y = _mm_rsqrt_ss(vd); // estimate 
         
         //  one step NR 
-        z = v1_5;
-        vd = _mm_mul_ss(vd, vHalf); // vd * 0.5	
+        z = b3v1_5;
+        vd = _mm_mul_ss(vd, b3vHalf); // vd * 0.5	
         //x2 = vd;
         vd = _mm_mul_ss(vd, y); // vd * 0.5 * y0
         vd = _mm_mul_ss(vd, y); // vd * 0.5 * y0 * y0
@@ -826,7 +826,7 @@ operator/(const b3Vector3& v, const b3Scalar& s)
 #if 0 //defined(B3_USE_SSE_IN_API)
 // this code is not faster !
 	__m128 vs = _mm_load_ss(&s);
-    vs = _mm_div_ss(v1110, vs);
+    vs = _mm_div_ss(b3v1110, vs);
 	vs = b3_pshufd_ps(vs, 0x00);	//	(S S S S)
 
 	return b3Vector3(_mm_mul_ps(v.mVec128, vs));
diff --git a/src/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.cpp b/src/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.cpp
index 6f28f92c0..05fc64d6e 100644
--- a/src/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.cpp
+++ b/src/Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.cpp
@@ -346,7 +346,7 @@ void	b3QuantizedBvh::reportAabbOverlappingNodex(b3NodeOverlapCallback* nodeCallb
 }
 
 
-int maxIterations = 0;
+static int b3s_maxIterations = 0;
 
 
 void	b3QuantizedBvh::walkStacklessTree(b3NodeOverlapCallback* nodeCallback,const b3Vector3& aabbMin,const b3Vector3& aabbMax) const
@@ -387,8 +387,8 @@ void	b3QuantizedBvh::walkStacklessTree(b3NodeOverlapCallback* nodeCallback,const
 			curIndex += escapeIndex;
 		}
 	}
-	if (maxIterations < walkIterations)
-		maxIterations = walkIterations;
+	if (b3s_maxIterations < walkIterations)
+		b3s_maxIterations = walkIterations;
 
 }
 
@@ -530,8 +530,8 @@ void	b3QuantizedBvh::walkStacklessTreeAgainstRay(b3NodeOverlapCallback* nodeCall
 			curIndex += escapeIndex;
 		}
 	}
-	if (maxIterations < walkIterations)
-		maxIterations = walkIterations;
+	if (b3s_maxIterations < walkIterations)
+		b3s_maxIterations = walkIterations;
 
 }
 
@@ -658,8 +658,8 @@ void	b3QuantizedBvh::walkStacklessQuantizedTreeAgainstRay(b3NodeOverlapCallback*
 			curIndex += escapeIndex;
 		}
 	}
-	if (maxIterations < walkIterations)
-		maxIterations = walkIterations;
+	if (b3s_maxIterations < walkIterations)
+		b3s_maxIterations = walkIterations;
 
 }
 
@@ -723,8 +723,8 @@ void	b3QuantizedBvh::walkStacklessQuantizedTree(b3NodeOverlapCallback* nodeCallb
 			curIndex += escapeIndex;
 		}
 	}
-	if (maxIterations < walkIterations)
-		maxIterations = walkIterations;
+	if (b3s_maxIterations < walkIterations)
+		b3s_maxIterations = walkIterations;
 
 }
 
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp b/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp
index e23ead86e..563c4dae5 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.cpp
@@ -899,3 +899,20 @@ void	b3GpuNarrowPhase::writeAllBodiesToGpu()
 	
     
 }
+
+void	b3GpuNarrowPhase::readbackAllBodiesToCpu()
+{
+	m_data->m_bodyBufferGPU->copyToHostPointer(&m_data->m_bodyBufferCPU->at(0),m_data->m_numAcceleratedRigidBodies);
+}
+void	b3GpuNarrowPhase::getObjectTransformFromCpu(float* position, float* orientation , int bodyIndex) const
+{
+	position[0] = m_data->m_bodyBufferCPU->at(bodyIndex).m_pos.x;
+	position[1] = m_data->m_bodyBufferCPU->at(bodyIndex).m_pos.y;
+	position[2] = m_data->m_bodyBufferCPU->at(bodyIndex).m_pos.z;
+	position[3] = 1.f;//or 1
+
+	orientation[0] = m_data->m_bodyBufferCPU->at(bodyIndex).m_quat.x;
+	orientation[1] = m_data->m_bodyBufferCPU->at(bodyIndex).m_quat.y;
+	orientation[2] = m_data->m_bodyBufferCPU->at(bodyIndex).m_quat.z;
+	orientation[3] = m_data->m_bodyBufferCPU->at(bodyIndex).m_quat.w;
+}
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp
index c6c5b445d..843849211 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.cpp
@@ -37,7 +37,7 @@ bool dumpContactStats = false;
 
 
 
-b3GpuRigidBodyPipeline::b3GpuRigidBodyPipeline(cl_context ctx,cl_device_id device, cl_command_queue  q,class b3GpuNarrowPhase* narrowphase, class b3GpuSapBroadphase* broadphaseSap , class b3DynamicBvhBroadphase* broadphaseDbvt)
+b3GpuRigidBodyPipeline::b3GpuRigidBodyPipeline(cl_context ctx,cl_device_id device, cl_command_queue  q,class b3GpuNarrowPhase* narrowphase, class b3GpuSapBroadphase* broadphaseSap , struct b3DynamicBvhBroadphase* broadphaseDbvt)
 {
 	m_data = new b3GpuRigidBodyPipelineInternalData;
 	m_data->m_context = ctx;
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h
index f8eea8122..25e2d743f 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h
@@ -13,7 +13,7 @@ protected:
 public:
 
 
-	b3GpuRigidBodyPipeline(cl_context ctx,cl_device_id device, cl_command_queue  q , class b3GpuNarrowPhase* narrowphase, class b3GpuSapBroadphase* broadphaseSap, class b3DynamicBvhBroadphase* broadphaseDbvt);
+	b3GpuRigidBodyPipeline(cl_context ctx,cl_device_id device, cl_command_queue  q , class b3GpuNarrowPhase* narrowphase, class b3GpuSapBroadphase* broadphaseSap, struct b3DynamicBvhBroadphase* broadphaseDbvt);
 	virtual ~b3GpuRigidBodyPipeline();
 
 	void	stepSimulation(float deltaTime);
diff --git a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h
index 1e262bb65..0251d38c6 100644
--- a/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h
+++ b/src/Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h
@@ -30,7 +30,7 @@ struct b3GpuRigidBodyPipelineInternalData
 	
 	class b3GpuSapBroadphase* m_broadphaseSap;
 	
-	class b3DynamicBvhBroadphase* m_broadphaseDbvt;
+	struct b3DynamicBvhBroadphase* m_broadphaseDbvt;
 	b3OpenCLArray<b3SapAabb>*	m_allAabbsGPU;
 	b3AlignedObjectArray<b3SapAabb>	m_allAabbsCPU;
 	b3OpenCLArray<b3BroadphasePair>*		m_overlappingPairsGPU;