diff --git a/samples/life/.classpath b/samples/life/.classpath
new file mode 100644
index 0000000000000000000000000000000000000000..2b3d42947b0a9f028e1acf3ee7d6963e71b1003c
--- /dev/null
+++ b/samples/life/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/com.amd.aparapi"/>
+	<classpathentry kind="output" path="classes"/>
+</classpath>
diff --git a/samples/life/.project b/samples/life/.project
new file mode 100644
index 0000000000000000000000000000000000000000..01f51c901246336b518330a59bde17d074705c3c
--- /dev/null
+++ b/samples/life/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>life</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/samples/life/build.xml b/samples/life/build.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3f18acb6ddec58bf60d6c27ff89f2c45b1165d94
--- /dev/null
+++ b/samples/life/build.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+
+<project name="life" default="build" basedir=".">
+   <target name="build" depends="clean">
+      <mkdir dir="classes"/>
+      <javac srcdir="src" destdir="classes" debug="on" includeantruntime="false" >
+         <classpath>
+            <pathelement path="../../com.amd.aparapi/aparapi.jar"/>
+         </classpath>
+      </javac>
+      <jar jarfile="${ant.project.name}.jar" basedir="classes"/>
+   </target>
+
+   <target name="clean">
+      <delete dir="classes"/>
+      <delete file="${ant.project.name}.jar"/>
+   </target>
+
+
+</project>
diff --git a/samples/life/life.bat b/samples/life/life.bat
new file mode 100644
index 0000000000000000000000000000000000000000..4a35d22f8bc14eb34dce93e6e9421b9ac0aa347c
--- /dev/null
+++ b/samples/life/life.bat
@@ -0,0 +1,7 @@
+java ^
+ -Djava.library.path=../../com.amd.aparapi.jni ^
+ -Dcom.amd.aparapi.executionMode=%1 ^
+ -classpath ../../com.amd.aparapi/aparapi.jar;life.jar ^
+ com.amd.aparapi.sample.life.Main
+
+
diff --git a/samples/life/src/com/amd/aparapi/sample/life/Main.java b/samples/life/src/com/amd/aparapi/sample/life/Main.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0bbeacf32d1095ab0b0c34b9c56afad66dc0e4b
--- /dev/null
+++ b/samples/life/src/com/amd/aparapi/sample/life/Main.java
@@ -0,0 +1,213 @@
+/*
+Copyright (c) 2010-2011, Advanced Micro Devices, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer. 
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution. 
+
+Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+If you use the software (in whole or in part), you shall adhere to all applicable U.S., European, and other export
+laws, including but not limited to the U.S. Export Administration Regulations ("EAR"), (15 C.F.R. Sections 730 through
+774), and E.U. Council Regulation (EC) No 1334/2000 of 22 June 2000.  Further, pursuant to Section 740.6 of the EAR,
+you hereby certify that, except pursuant to a license granted by the United States Department of Commerce Bureau of 
+Industry and Security or as otherwise permitted pursuant to a License Exception under the U.S. Export Administration 
+Regulations ("EAR"), you will not (1) export, re-export or release to a national of a country in Country Groups D:1,
+E:1 or E:2 any restricted technology, software, or source code you receive hereunder, or (2) export to Country Groups
+D:1, E:1 or E:2 the direct product of such technology or software, if such foreign produced direct product is subject
+to national security controls as identified on the Commerce Control List (currently found in Supplement 1 to Part 774
+of EAR).  For the most current Country Group listings, or for additional information about the EAR or your obligations
+under those regulations, please refer to the U.S. Bureau of Industry and Security's website at http://www.bis.doc.gov/. 
+
+*/
+
+package com.amd.aparapi.sample.life;
+
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferInt;
+
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.WindowConstants;
+
+import com.amd.aparapi.Kernel;
+
+/**
+ * An example Aparapi application which demonstrates Conways 'Game Of Life'.
+ * 
+ * Original code from Witold Bolt's site https://github.com/houp/aparapi/tree/master/samples/gameoflife.
+ * 
+ * Converted to use int buffer and some performance tweaks by Gary Frost
+ * 
+ * @author Wiltold Bolt
+ * @author Gary Frost
+ */
+public class Main{
+
+   /**
+    * LifeKernel represents the data parallel algorithm describing by Conway's game of life.
+    * 
+    * http://en.wikipedia.org/wiki/Conway's_Game_of_Life
+    * 
+    * We examine the state of each pixel and its 8 neighbors and apply the following rules. 
+    * 
+    * if pixel is dead (off) and number of neighbors == 3 {
+    *       pixel is turned on
+    * } else if pixel is alive (on) and number of neighbors is neither 2 or 3
+    *       pixel is turned off
+    * }
+    * 
+    * We use an image buffer which is 2*width*height the size of screen and we use fromBase and toBase to track which half of the buffer is being mutated for each pass. We basically 
+    * copy from getGlobalId()+fromBase to getGlobalId()+toBase;
+    * 
+    * 
+    * Prior to each pass the values of fromBase and toBase are swapped.
+    *
+    */
+
+   public static class LifeKernel extends Kernel{
+
+      private static final int ALIVE = 0xffffff;
+
+      private static final int DEAD = 0;
+
+      private final int[] imageData;
+
+      private final int width;
+
+      private final int height;
+
+      private int fromBase;
+
+      private int toBase;
+
+      public LifeKernel(int _width, int _height, BufferedImage _image) {
+         imageData = ((DataBufferInt) _image.getRaster().getDataBuffer()).getData();
+         width = _width;
+         height = _height;
+         fromBase = height * width;
+         toBase = 0;
+         setExplicit(true); // This gives us a performance boost
+         
+         /** draw a line across the image **/
+         for (int i = width * (height / 2) + width / 10; i < width * (height / 2 + 1) - width / 10; i++) {
+            imageData[i] = LifeKernel.ALIVE;
+         }
+         
+         put(imageData); // Because we are using explicit buffer management we must put the imageData array
+
+      }
+
+      @Override public void run() {
+         int gid = getGlobalId();
+         int to = gid + toBase;
+         int from = gid + fromBase;
+         int x = gid % width;
+         int y = gid / width;
+
+         if ((x == 0 || x == width - 1 || y == 0 || y == height - 1)) {
+            // This pixel is on the border of the view, just keep existing value
+            imageData[to] = imageData[from];
+         } else {
+            // Count the number of neighbors.  We use (value&1x) to turn pixel value into either 0 or 1
+            int neighbors = (imageData[from - 1] & 1) + // EAST
+                  (imageData[from + 1] & 1) + // WEST
+                  (imageData[from - width - 1] & 1) + // NORTHEAST                 
+                  (imageData[from - width] & 1) + // NORTH
+                  (imageData[from - width + 1] & 1) + // NORTHWEST
+                  (imageData[from + width - 1] & 1) + // SOUTHEAST
+                  (imageData[from + width] & 1) + // SOUTH
+                  (imageData[from + width + 1] & 1); // SOUTHWEST
+
+            // The game of life logic
+            if (neighbors == 3 || (neighbors == 2 && imageData[from] == ALIVE)) {
+               imageData[to] = ALIVE;
+            } else {
+               imageData[to] = DEAD;
+            }
+
+         }
+
+      }
+
+      public void nextGeneration() {
+         // swap fromBase and toBase
+         int swap = fromBase;
+         fromBase = toBase;
+         toBase = swap;
+
+         execute(width * height);
+      }
+
+   }
+
+   public static void main(String[] _args) {
+
+      JFrame frame = new JFrame("Game of Life");
+      final int width = Integer.getInteger("width", 1024 + 512);
+
+      final int height = Integer.getInteger("height", 768);
+
+      // Buffer is twice the size as the screen.  We will alternate between mutating data from top to bottom
+      // and bottom to top in alternate generation passses. The LifeKernel will track which pass is which
+      final BufferedImage image = new BufferedImage(width, height * 2, BufferedImage.TYPE_INT_RGB);
+
+      final LifeKernel lifeKernel = new LifeKernel(width, height, image);
+
+      // Create a component for viewing the offsecreen image
+      @SuppressWarnings("serial") JComponent viewer = new JComponent(){
+         @Override public void paintComponent(Graphics g) {
+            if (lifeKernel.isExplicit()) {
+               lifeKernel.get(lifeKernel.imageData); // We only pull the imageData when we intend to use it.
+            }
+            // We copy one half of the offscreen buffer to the viewer, we copy the half that we just mutated.
+            if (lifeKernel.fromBase == 0) {
+               g.drawImage(image, 0, 0, width, height, 0, 0, width, height, this);
+            } else {
+               g.drawImage(image, 0, 0, width, height, 0, height, width, 2 * height, this);
+            }
+         }
+      };
+
+      // Set the default size and add to the frames content pane
+      viewer.setPreferredSize(new Dimension(width, height));
+      frame.getContentPane().add(viewer);
+      
+      // Swing housekeeping
+      frame.pack();
+      frame.setVisible(true);
+      frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+
+      long start = System.currentTimeMillis();
+      long generations = 0;
+      while (true) {
+         lifeKernel.nextGeneration();  // Work is performed here
+         viewer.repaint();             // Request a repaint of the viewer (causes paintComponent(Graphics) to be called later not synchronous
+         generations++;
+         long now = System.currentTimeMillis();
+         if (now - start > 1000) {
+            frame.setTitle(lifeKernel.getExecutionMode() + " generations per second: " + (generations * 1000.0) / (now - start));
+            start = now;
+            generations = 0;
+         }
+      }
+
+   }
+}