source-academy · Apr 29, 2020
diff --git a/‎docs/md/README_4_GPU.md
+104 b/‎docs/md/README_4_GPU.md
+104
diff --git a/‎docs/md/README_top.md
+2 b/‎docs/md/README_top.md
+2
diff --git a/‎docs/specs/source_4_gpu.tex
+179 b/‎docs/specs/source_4_gpu.tex
+179
diff --git a/‎package.json
+2-1 b/‎package.json
+2-1
diff --git a/‎scripts/jsdoc.sh
+13 b/‎scripts/jsdoc.sh
+13
diff --git a/‎src/__tests__/stringify.ts
+232-232 b/‎src/__tests__/stringify.ts
+232-232
diff --git a/‎src/createContext.ts
+3-1 b/‎src/createContext.ts
+3-1
diff --git a/‎src/gpu/__tests__/noTranspile.ts
+257 b/‎src/gpu/__tests__/noTranspile.ts
+257
diff --git a/‎src/gpu/__tests__/runtimeError.ts
+38 b/‎src/gpu/__tests__/runtimeError.ts
+38
diff --git a/‎src/gpu/__tests__/runtimeOk.ts
+184 b/‎src/gpu/__tests__/runtimeOk.ts
+184
diff --git a/‎src/gpu/__tests__/transpile.ts
+320 b/‎src/gpu/__tests__/transpile.ts
+320
diff --git a/‎src/gpu/gpu.ts
+58 b/‎src/gpu/gpu.ts
+58
diff --git a/‎src/gpu/lib.ts
+193 b/‎src/gpu/lib.ts
+193
diff --git a/‎src/gpu/transfomer.ts
+320 b/‎src/gpu/transfomer.ts
+320
diff --git a/‎src/gpu/verification/bodyVerifier.ts
+211 b/‎src/gpu/verification/bodyVerifier.ts
+211
diff --git a/‎src/gpu/verification/loopVerifier.ts
+131 b/‎src/gpu/verification/loopVerifier.ts
+131
diff --git a/‎src/transpiler/transpiler.ts
+185-109 b/‎src/transpiler/transpiler.ts
+185-109
diff --git a/‎src/types.ts
+1-1 b/‎src/types.ts
+1-1
diff --git a/‎src/utils/astCreator.ts
+36 b/‎src/utils/astCreator.ts
+36
diff --git a/‎yarn.lock
+1,813-1,205 b/‎yarn.lock
+1,813-1,205
@@ -0,0 +1,104 @@
+Source §4 GPU is a small programming language, designed to allow users to accelerate their programs 
+by making use of their GPUs!
+
+## What names are predeclared in Source §4 GPU?
+
+On the right, you see all predeclared names of Source §4, in alphabetical
+order. Click on a name to see how it is used. They come in these two groups:
+  <ul>
+    <li>
+      <a href="../MISC/index.html">MISC</a>: Miscellaneous constants and functions
+    </li>
+    <li>
+      <a href="../MATH/index.html">MATH</a>: Mathematical constants and functions
+    </li>
+    <li>
+      <a href="../LISTS/index.html">LISTS</a>: Support for lists
+    </li>
+    <li>
+      <a href="../PAIRMUTATORS/index.html">PAIRMUTATORS</a>: Mutating pairs
+    </li>
+    <li>
+      <a href="../ARRAYS/index.html">ARRAYS</a>: Support for arrays
+    </li>
+    <li>
+      <a href="../STREAMS/index.html">STREAMS</a>: Support for streams
+    </li>
+    <li>
+      <a href="../MCE/index.html">MCE</a>: Support for the meta-circular evaluator
+    </li>
+  </ul>
+
+The <a href="https://sourceacademy.nus.edu.sg">Source Academy</a>,
+a learning environment that uses SICP JS and Source, comes with the following 
+<a href="External libraries/">external libraries</a>:
+  <ul>
+    <li>
+      <a href="../RUNES/index.html">RUNES</a>: Library for runes graphics
+    </li>
+    <li>
+      <a href="../CURVES/index.html">CURVES</a>: Library for curve graphics
+    </li>
+    <li>
+      <a href="../SOUNDS/index.html">SOUNDS</a>: Library for sound processing
+    </li>
+    <li>
+      <a href="../BINARYTREES/index.html">BINARYTREES</a>: Library for binary trees
+    </li>
+    <li>
+    <a href="../PIX%26FLIX/index.html">PIX&amp;FLIX</a>: image and video processing
+    </li>
+  </ul>
+
+## What can you do in Source §4 GPU?
+
+You can write for loops as per normal source and if certain conditions are met, the GPU will 
+be invoked to run the program!
+
+### Example:
+
+```=javascript
+const size = 100;
+
+const L = [];
+const R = [];
+for (let r = 0; r < size; r = r + 1) {
+    L[r] = [];
+    R[r] = [];
+    for (let c = 0; c < size; c = c + 1) {
+        L[r][c] = r*c;
+        R[r][c] = r + c;
+    }
+}
+
+const res = [];
+for (let r = 0; r < size; r = r + 1) {
+    res[r] = [];
+}
+
+const startTime = runtime();
+for (let r = 0; r < size; r = r + 1) {
+    for (let c = 0; c < size; c = c + 1) {
+        let sum = 0;
+        for (let i = 0; i < size; i = i + 1) {
+            sum = sum + L[r][i] * R[i][c];
+        }
+        res[r][c] = sum;
+    }
+}
+
+const endTime = runtime();
+const elapsed = endTime - startTime;
+
+display(res);
+display(elapsed, "Time taken: ");
+```
+
+## You want the definitive specs?
+
+For our development team, we are maintaining a definitive description
+of the language, called the
+<a href="../source_4_gpu.pdf">Specification of Source §4 GPU</a>. Feel free to
+take a peek!
+
+
@@ -27,6 +27,8 @@
 
 ## <a href="source_4/">Source §4</a>
 
+## <a href="source_4_gpu/">Source §4 GPU</a>
+
 ## <a href="External libraries/">External Libraries</a>
 
 The <a href="https://sourceacademy.nus.edu.sg">Source Academy</a>,
 
@@ -0,0 +1,179 @@
+\input source_header.tex
+
+\begin{document}
+	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	\docheader{2021}{Source}{\S 4 GPU}{Martin Henz, Rahul Rajesh, Zhang Yuntong}
+	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\input source_intro.tex
+
+\section*{Changes}
+
+Source \S 4 GPU allows for Source programs to be accelerated on the GPU if certain conditions are met.
+The exact specifications for this is outlined on page \pageref{gpu_supp}. Source \S 4 GPU  defines a formal specification 
+to identify areas in the program that are embarrssingly parallel (e.g. for loops etc.) . These will then
+be run in parallel across GPU threads. Experimentation has shown that Source \S 4 GPU is orders of magnitude faster
+than Source \S 4 for heavy CPU bound tasks (matrix multiplication of large matrices)
+
+\input source_bnf.tex
+
+\input source_3_bnf.tex
+
+\newpage
+
+\input source_boolean_operators
+
+\input source_loops
+
+\input source_return_3
+
+\input source_names
+
+\input source_lists
+
+\input source_pair_mutators
+
+\input source_array_support
+
+\input source_streams
+
+\input source_numbers
+
+\input source_strings
+
+\input source_arrays
+
+\input source_typing_3
+
+\input source_interpreter
+
+\input source_comments
+
+\input source_js_differences
+
+\newpage
+
+\section*{GPU Acceleration}
+\label{gpu_supp}
+This section outlines the specifications for programs to be accelerated using the GPU.\
+\input source_gpu_bnf.tex
+
+\newpage
+
+\section*{Restrictions}
+
+Even if the BNF syntax is met, GPU acceleration can only take place if all the restrictions below are satisfied. If all criteria are met, the \textit{gpu\_statement} loops are embarrassingly parallel.
+
+\subsection*{Special For Loops}
+
+In the BNF, we have special loops that take on this form:
+\begin{alignat*}{9}
+&& \textbf{\texttt{for}}\ \textbf{\texttt{(}} 
+                          \ \textit{gpu\_for\_let} \textbf{\texttt{;}} \\
+&& \ \ \textit{gpu\_condition} \textbf{\texttt{;}} \\
+&& \textit{gpu\_for\_assignment} \ \textbf{\texttt{)}} 
+\end{alignat*}
+
+These are the loops that will be taken into consideration for parallelization. However, on top of the BNF syntax, the below requirement must also be statisfied:
+
+\begin{itemize}
+    \item{the names declared in each \textit{gpu\_for\_let} have to be different across the loops}
+    \item{in each loop, the \textit{gpu\_condition} and the \textit{gpu\_for\_assignment} must use the name declared
+    in the respective \textit{gpu\_for\_let} statement}
+\end{itemize}
+
+\subsection*{GPU Function}
+
+A \textit{gpu\_function} has to be a \textit{math\_\texttt{*}} function
+
+\subsection*{Core Statement}
+
+Within \textit{core\_statement}, there are some constraints:
+
+\begin{itemize}
+    \item{no assignment to any global variables (all assignments can only be done to variables defined in the \textit{gpu\_block}})
+    \item{no use of the variable in \textit{gpu\_result\_assignment} at an offset from the current index e.g. cannot be i - 1}
+\end{itemize}
+
+\subsection*{GPU Result Statement}
+
+The \textit{gpu\_result\_assignment} is the statement that stores a value calculated in core statements into a result array. 
+It access an array at a certain coordinate e.g. ${array[{i_1}][{i_2}][{i_3}]}$. For this:
+
+\begin{itemize}
+    \item{This result array has to be defined outside the \textit{gpu\_block}.}
+    \item{The sequence of coordinates which we access in the result array ${{i_1}, {i_2}, {i_3} ... i_{k}}$ must be a 
+        prefix of the special for loop counters ${[c_1,c_2 ... c_n]}$.}
+    \item{ If you have ${n}$ special for loops, the array expression can take on ${k}$ coordinates where ${0 < k \leq n}$. 
+    The order matters as well, it has to follow the same order as the special for loops: you cannot have ${name[c_2][c_1]}$.}
+\end{itemize}
+
+\section*{Examples}
+
+Below are some examples of valid and invalid source gpu programs:\\
+
+\textbf{Valid} - Using first loop counter. (meaning the loop will be run across N threads; the first loop is parallelized away):
+\begin{verbatim}
+for (let i = 0; i < N; i = i + 1) {
+    for (let k = 0; k < M; k = k + 1) {
+        res[i] = arr[k % 2] + 1;
+    }
+}
+\end{verbatim}
+
+\textbf{Invalid} - Counter used is not a prefix of for loop counters:
+\begin{verbatim}
+for (let i = 0; i < N; i = i + 1) {
+    for (let k = 0; k < M; k = k + 1) {
+        res[k] = arr[i % 2] + 1;
+    }
+}
+\end{verbatim}
+
+\textbf{Valid} - Using first three loop counters (meaning the loop will be run across N*M*C threads, if available):
+\begin{verbatim}
+for (let i = 0; i < N; i = i + 1) {
+    for (let j = 0; j < M; j = j + 1) {
+        for (let k = 0; k < C; k = k + 1) {
+            let x = math_pow(2, 10);
+            let y = x * (1000);
+            arr[i][j][k] = (x + y * 2);
+        }
+    }
+}
+\end{verbatim}
+
+\textbf{Invalid} - Indices are in wrong order (must respect for loop counter orders):
+\begin{verbatim}
+for (let i = 0; i < N; i = i + 1) {
+    for (let j = 0; j < M; j = j + 1) {
+        for (let k = 0; k < C; k = k + 1) {
+            let x = math_pow(2, 10);
+            let y = x * (1000);
+            res[k][j][i] = (x + y * 2);
+        }
+    }
+}
+\end{verbatim}
+
+\textbf{Invalid} - Using an index that is not part of a special for loop (see above):
+\begin{verbatim}
+for (let i = 0; i < N; i = i + 1) {
+    for (let j = 0; j < M; j = j + 1) {
+        for (let k = 1; k < C; k = k + 2) {
+            res[k] = arr1[i] + arr2[j];
+        }
+    }
+}
+\end{verbatim}
+
+\newpage
+
+\input source_list_library
+
+\newpage
+
+\input source_stream_library
+
+
+\end{document}
@@ -26,7 +26,8 @@
     "lodash": "^4.17.13",
     "node-getopt": "^0.3.2",
     "source-map": "^0.7.3",
-    "xmlhttprequest-ts": "^1.0.1"
+    "xmlhttprequest-ts": "^1.0.1",
+    "gpu.js": "^2.9.3"
   },
   "main": "dist/index",
   "types": "dist/index",
 
@@ -136,6 +136,19 @@ run() {
 	     ${LIB}/array.js \
 	     ${LIB}/pairmutator.js \
 	     ${LIB}/mce.js
+
+    # Source §4 GPU
+    
+    ${JSDOC} -r -t ${TMPL} \
+	     -c docs/jsdoc/conf.json \
+	     -R ${MD}/README_4_GPU.md \
+	     -d ${DST}/"source_4_gpu"/ \
+	     ${LIB}/misc.js \
+	     ${LIB}/math.js \
+		 ${LIB}/list.js \
+	     ${LIB}/stream.js \
+	     ${LIB}/array.js \
+	     ${LIB}/pairmutator.js 
 
     # MISC
 
 
@@ -12,6 +12,7 @@ import * as stream from './stdlib/stream'
 import { streamPrelude } from './stdlib/stream.prelude'
 import { Context, CustomBuiltIns, Value, Variant } from './types'
 import * as operators from './utils/operators'
+import * as gpu_lib from './gpu/lib'
 import { stringify } from './utils/stringify'
 import { lazyListPrelude } from './stdlib/lazyList.prelude'
 export class LazyBuiltIn {
@@ -59,7 +60,8 @@ export const createEmptyContext = <T>(
   }
   const length = GLOBAL[GLOBAL_KEY_TO_ACCESS_NATIVE_STORAGE].push({
     globals: { variables: new Map(), previousScope: null },
-    operators: new Map(Object.entries(operators))
+    operators: new Map(Object.entries(operators)),
+    gpu: new Map(Object.entries(gpu_lib))
   })
   return {
     chapter,
 
@@ -0,0 +1,257 @@
+import { mockContext } from '../../mocks/context'
+import { parse } from '../../parser/parser'
+import { stripIndent } from '../../utils/formatters'
+import { transpile } from '../../transpiler/transpiler'
+
+test('empty for loop does not get transpiled', () => {
+  const code = stripIndent`
+    for (let i = 0; i < 10; i = i + 1) {}
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with different update does not get transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 2) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with different loop variables does not get transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    let j = 0;
+    for (let i = 0; j < 5; j = j + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with const initialization does not get transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    let j = 0;
+    for (const i = 0; i < 5; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with non-zero initialization does not get transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 1; i < 5; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with a function end counter does not get transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    let f = () => 5;
+    for (let i = 1; i < f(); i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with different initialization does not get transpiled', () => {
+  const code = stripIndent`
+      let res = [];
+      let i = 0;
+      for (i = 0; i < 5; i = i + 2) {
+          res[i] = i;
+      }
+      `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with global variable update does not get transpiled', () => {
+  const code = stripIndent`
+      let res = [];
+      let y = 5;
+      for (let i = 0; i < 5; i = i + 1) {
+          y = y + 1;
+          res[i] = i;
+      }
+      `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with function call does not get transpiled', () => {
+  const code = stripIndent`
+        let res = [];
+        let y = () => 1;
+        for (let i = 0; i < 5; i = i + 1) {
+            y();
+            res[i] = i;
+        }
+        `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('simple for loop with double update does not get transpiled', () => {
+  const code = stripIndent`
+        let res = [];
+        for (let i = 0; i < 5; i = i + 1) {
+            res[i] = i;
+            res[i] = i + 1;
+        }
+        `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('2 for loops with wrong indice order does not get transpiled', () => {
+  const code = stripIndent`
+        let res = [];
+        for (let i = 0; i < 5; i = i + 1) {
+            for (let j = 0; j < 5; j = j + 1) {
+                res[j][i] = i + 1;
+            }
+        }
+        `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('2 for loops with wrong indices order does not get transpiled', () => {
+  const code = stripIndent`
+        let res = [];
+        for (let i = 0; i < 5; i = i + 1) {
+            for (let j = 0; j < 5; j = j + 1) {
+                res[j] = i + 1;
+            }
+        }
+        `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('2 for loop case with 2 indices being written + use of result variable[i-1][j] does not get transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+      res[i] = [];
+      for (let j = 0; j < 5; j = j + 1) {
+        res[i][j] = j;
+      }
+    }
+
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            let x = res[i-1][j];
+            let y = math_abs(x * -5);
+            res[i][j] = x + y;
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('3 for loops with wrong indice order does not get transpiled', () => {
+  const code = stripIndent`
+        let res = [];
+        for (let i = 0; i < 5; i = i + 1) {
+            for (let j = 0; j < 5; j = j + 1) {
+                for (let k = 0; k < 5; k = k + 1) {
+                    res[k][j][i] = i + 1;
+                }
+            }
+        }
+        `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
+
+test('3 for loops with wrong indice order does not get transpiled', () => {
+  const code = stripIndent`
+        let res = [];
+        for (let i = 0; i < 5; i = i + 1) {
+            for (let j = 0; j < 5; j = j + 1) {
+                for (let k = 0; k < 5; k = k + 1) {
+                    res[j][k] = i + 1;
+                }
+            }
+        }
+        `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(2)
+})
@@ -0,0 +1,38 @@
+/* tslint:disable:only-arrow-functions */
+import { __createKernel } from '../lib'
+import { TypeError } from '../../utils/rttc'
+
+test('__createKernel with uninitialized array throws error', () => {
+  const bounds = [5, 4]
+  const extern = {}
+  const f1 = function(this: any) {
+    return this.thread.y * this.thread.x
+  }
+
+  const arr: number[][] = []
+
+  const f2 = function(i: any, j: any) {
+    return i * j
+  }
+  const f = () => __createKernel(bounds, extern, f1, arr, f2)
+  expect(f).toThrow(TypeError)
+})
+
+test('__createKernel with 2 loops + uninitialized array throws error', () => {
+  const bounds = [5, 4, 3]
+  const extern = {}
+  const f1 = function(this: any) {
+    return this.thread.z * this.thread.y * this.thread.x
+  }
+
+  const arr: number[][][] = []
+  for (let i = 0; i < 5; i = i + 1) {
+    arr[i] = []
+  }
+
+  const f2 = function(i: any, j: any, k: any) {
+    return i * j * k
+  }
+  const f = () => __createKernel(bounds, extern, f1, arr, f2)
+  expect(f).toThrow(TypeError)
+})
@@ -0,0 +1,184 @@
+/* tslint:disable:only-arrow-functions */
+import { __createKernel } from '../lib'
+
+test('__createKernel with 1 loop returns correct result', () => {
+  const bounds = [5]
+  const extern = {}
+  const f1 = function() {
+    return 1
+  }
+  const arr: number[] = []
+  const f2 = function(i: any) {
+    return 1
+  }
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([1, 1, 1, 1, 1])
+})
+
+test('__createKernel with 2 loops returns correct result', () => {
+  const bounds = [5, 4]
+  const extern = {}
+  const f1 = function(this: any) {
+    return this.thread.y * this.thread.x
+  }
+
+  const arr: number[][] = []
+  for (let i = 0; i < 5; i = i + 1) {
+    arr[i] = []
+  }
+
+  const f2 = function(i: any, j: any) {
+    return i * j
+  }
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([
+    [0, 0, 0, 0],
+    [0, 1, 2, 3],
+    [0, 2, 4, 6],
+    [0, 3, 6, 9],
+    [0, 4, 8, 12]
+  ])
+})
+
+test('__createKernel with 3 loop returns correct result', () => {
+  const bounds = [5, 4, 3]
+  const extern = {}
+  const f1 = function(this: any) {
+    return this.thread.z * this.thread.y * this.thread.x
+  }
+
+  const arr: number[][][] = []
+  for (let i = 0; i < 5; i = i + 1) {
+    arr[i] = []
+    for (let j = 0; j < 4; j = j + 1) {
+      arr[i][j] = []
+    }
+  }
+
+  const f2 = function(i: any, j: any, k: any) {
+    return i * j * k
+  }
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([
+    [
+      [0, 0, 0],
+      [0, 0, 0],
+      [0, 0, 0],
+      [0, 0, 0]
+    ],
+    [
+      [0, 0, 0],
+      [0, 1, 2],
+      [0, 2, 4],
+      [0, 3, 6]
+    ],
+    [
+      [0, 0, 0],
+      [0, 2, 4],
+      [0, 4, 8],
+      [0, 6, 12]
+    ],
+    [
+      [0, 0, 0],
+      [0, 3, 6],
+      [0, 6, 12],
+      [0, 9, 18]
+    ],
+    [
+      [0, 0, 0],
+      [0, 4, 8],
+      [0, 8, 16],
+      [0, 12, 24]
+    ]
+  ])
+})
+
+test('__createKernel with 1 loop + return string returns correct result', () => {
+  const bounds = [5]
+  const extern = {}
+  const f1 = function() {
+    return 'a'
+  }
+  const arr: number[] = []
+  const f2 = function() {
+    return 'a'
+  }
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual(['a', 'a', 'a', 'a', 'a'])
+})
+
+test('__createKernel with 1 loop + return number array returns correct result', () => {
+  const bounds = [5]
+  const extern = {}
+  const f1 = function() {
+    return [1, 2, 3]
+  }
+  const arr: number[] = []
+  const f2 = function() {
+    return [1, 2, 3]
+  }
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([
+    [1, 2, 3],
+    [1, 2, 3],
+    [1, 2, 3],
+    [1, 2, 3],
+    [1, 2, 3]
+  ])
+})
+
+test('__createKernel with 1 loop + return string array returns correct result', () => {
+  const bounds = [5]
+  const extern = {}
+  const f1 = function() {
+    return ['a', 'a']
+  }
+  const arr: number[] = []
+  const f2 = function() {
+    return ['a', 'a']
+  }
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([
+    ['a', 'a'],
+    ['a', 'a'],
+    ['a', 'a'],
+    ['a', 'a'],
+    ['a', 'a']
+  ])
+})
+
+test('__createKernel with 1 loop + external variable returns correct result', () => {
+  const bounds = [3]
+  const extern = { y: 100 }
+  const f1 = function(this: any) {
+    return this.constants.y + this.thread.x
+  }
+  const arr: number[] = []
+  const f2 = function() {
+    return 1 + y
+  }
+
+  const y = 100
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([101, 101, 101])
+})
+
+test('__createKernel with 1 loop + external variable + math function returns correct result', () => {
+  const bounds = [3]
+  const extern = { y: 100 }
+  const f1 = function(this: any) {
+    return Math.abs(-this.constants.y + this.thread.x)
+  }
+  const arr: number[] = []
+
+  const y = 100
+
+  // tslint:disable-next-line
+  const math_abs = Math.abs
+  const f2 = function(i: any) {
+    return math_abs(-y + i)
+  }
+
+  __createKernel(bounds, extern, f1, arr, f2)
+  expect(arr).toEqual([100, 99, 98])
+})
@@ -0,0 +1,320 @@
+import { mockContext } from '../../mocks/context'
+import { parse } from '../../parser/parser'
+import { stripIndent } from '../../utils/formatters'
+import { transpile } from '../../transpiler/transpiler'
+
+test('simple for loop gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('many simple for loop gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        res[i] = i;
+    }
+
+    let res1 = [];
+    for (let i = 0; i < 5; i = i + 1) {
+      res1[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(4)
+})
+
+test('simple for loop with constant condition transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    const c = 10;
+    for (let i = 0; i < c; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('simple for loop with let condition transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    let c = 10;
+    for (let i = 0; i < c; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('simple for loop with math function call transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    let c = 10;
+    for (let i = 0; i < c; i = i + 1) {
+        res[i] = math_abs(i);
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('simple for loop with different end condition transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    const f = () => 5;
+    let c = f();
+    for (let i = 0; i < c; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('2 for loop case gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            res[i] = i;
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('2 for loop case with body gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        let sum = 0;
+        for (let j = 0; j < 5; j = j + 1) {
+            sum = sum + j;
+        }
+        res[i] = sum;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('2 for loop case with 2 indices being written to gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            res[i][j] = i*j;
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('2 for loop case with 2 indices being written + local updates to gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res1 = [];
+    for (let i = 0; i < 5; i = i + 1) {
+      res1[i] = [];
+      for (let j = 0; j < 5; j = j + 1) {
+        res1[i][j] = j;
+      }
+    }
+
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            let x = res1[i][j];
+            let y = math_abs(x * -5);
+            res[i][j] = x + y;
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('2 for loop case with 2 indices being written + use of result variable[i][j] gets transpiled', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+      res[i] = [];
+      for (let j = 0; j < 5; j = j + 1) {
+        res[i][j] = j;
+      }
+    }
+
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            let x = res[i][j];
+            let y = math_abs(x * -5);
+            res[i][j] = x + y;
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('3 for loop case with 1 index being written to gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            for (let k = 0; k < 5; k = k + 1) {
+              res[i] = i*j;
+            }
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('3 for loop case with 2 indices being written to gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            for (let k = 0; k < 5; k = k + 1) {
+              res[i][j] = i*j;
+            }
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('3 for loop case with 3 indices being written to gets transpiled correctly', () => {
+  const code = stripIndent`
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        for (let j = 0; j < 5; j = j + 1) {
+            for (let k = 0; k < 5; k = k + 1) {
+              res[i][j][k] = i*j;
+            }
+        }
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(3)
+})
+
+test('many for loop case - matrix multiplication (2 transpilations)', () => {
+  const code = stripIndent`
+    const size = 10;
+    const L = [];
+    const R = [];
+    for (let r = 0; r < size; r = r + 1) {
+        L[r] = [];
+        R[r] = [];
+        for (let c = 0; c < size; c = c + 1) {
+            L[r][c] = r*c;
+            R[r][c] = r + c;
+        }
+    }
+
+    const res = [];
+    for (let r = 0; r < size; r = r + 1) {
+        res[r] = [];
+    }
+
+    for (let r = 0; r < size; r = r + 1) {
+        for (let c = 0; c < size; c = c + 1) {
+            let sum = 0;
+            for (let i = 0; i < size; i = i + 1) {
+                sum = sum + L[r][i] * R[i][c];
+            }
+            res[r][c] = sum;
+        }
+    }
+  `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  const cnt = transpiled.match(/__createKernel/g)?.length
+  expect(cnt).toEqual(4)
+})
+
+test('resolve naming conflicts if __createKernel is used', () => {
+  const code = stripIndent`
+    const __createKernel = 10;
+
+    let res = [];
+    for (let i = 0; i < 5; i = i + 1) {
+        res[i] = i;
+    }
+    `
+  const context = mockContext(4, 'gpu')
+  const transpiled = transpile(parse(code, context)!, context.contextId, false, context.variant)
+    .transpiled
+
+  // a new kernel function with name __createKernel0 should be created here
+  const cntNewName = transpiled.match(/__createKernel0/g)?.length
+  expect(cntNewName).toEqual(2)
+})
@@ -0,0 +1,58 @@
+import GPUTransformer from './transfomer'
+import { AllowedDeclarations } from '../types'
+import * as create from '../utils/astCreator'
+import * as es from 'estree'
+
+// top-level gpu functions that call our code
+
+// transpiles if possible and returns display statements to end user
+export function transpileToGPU(program: es.Program, kernelFunction: string): es.Statement[] {
+  // create unique kernel name
+  GPUTransformer.globalIds.__createKernel = create.identifier(kernelFunction)
+
+  const transformer = new GPUTransformer(program)
+  const res = transformer.transform()
+
+  const gpuDisplayStatements = []
+  // add some display statements to program
+  if (res.length > 0) {
+    for (const arr of res) {
+      let debug = `Attempting to optimize ${arr[1]} levels of nested loops starting on line ${arr[0]}`
+      if (arr[1] === 1) {
+        debug = `Attempting to optimize the loop on line ${arr[0]}`
+      }
+      gpuDisplayStatements.push(
+        create.expressionStatement(
+          create.callExpression(create.identifier('display'), [create.literal(debug)])
+        )
+      )
+    }
+  }
+  return gpuDisplayStatements
+}
+
+export function getInternalNamesForGPU(): Set<string> {
+  return new Set(Object.entries(GPUTransformer.globalIds).map(([key, { name }]) => key))
+}
+
+export function getInternalFunctionsForGPU(info: any, cid: any) {
+  return Object.entries(GPUTransformer.globalIds).map(([key, { name }]) => {
+    const kind: AllowedDeclarations = 'const'
+    const value: es.Expression = create.callExpression(
+      create.memberExpression(
+        create.memberExpression(
+          {
+            type: 'MemberExpression',
+            object: info.native,
+            property: create.literal(cid),
+            computed: true
+          },
+          'gpu'
+        ),
+        'get'
+      ),
+      [create.literal(key)]
+    )
+    return create.declaration(name, kind, value)
+  })
+}
@@ -0,0 +1,193 @@
+import { GPU } from 'gpu.js'
+import { TypeError } from '../utils/rttc'
+import { isArray } from 'util'
+
+// Heuristic : Only use GPU if array is bigger than this
+const MAX_SIZE = 200
+
+// helper function to build 2D array output
+function buildArray(arr: Float32Array[][], end: any, res: any) {
+  for (let i = 0; i < end[0]; i++) {
+    res[i] = prettyOutput(arr[i])
+  }
+}
+
+function build2DArray(arr: Float32Array[][], end: any, res: any) {
+  for (let i = 0; i < end[0]; i++) {
+    for (let j = 0; j < end[1]; j++) {
+      res[i][j] = prettyOutput(arr[i][j])
+    }
+  }
+}
+
+// helper function to build 3D array output
+function build3DArray(arr: Float32Array[][][], end: any, res: any) {
+  for (let i = 0; i < end[0]; i++) {
+    for (let j = 0; j < end[1]; j++) {
+      for (let k = 0; k < end[2]; k++) {
+        res[i][j][k] = prettyOutput(arr[i][j][k])
+      }
+    }
+  }
+}
+
+function prettyOutput(arr: any): any {
+  if (!(arr instanceof Float32Array)) {
+    return arr
+  }
+
+  const res = arr.map(x => prettyOutput(x))
+  return Array.from(res)
+}
+
+// helper function to check array is initialized
+function checkArray(arr: any): boolean {
+  return Array.isArray(arr)
+}
+
+// helper function to check 2D array is initialized
+function checkArray2D(arr: any, end: any): boolean {
+  for (let i = 0; i < end[0]; i = i + 1) {
+    if (!Array.isArray(arr[i])) return false
+  }
+  return true
+}
+
+// helper function to check 3D array is initialized
+function checkArray3D(arr: any, end: any): boolean {
+  for (let i = 0; i < end[0]; i = i + 1) {
+    if (!Array.isArray(arr[i])) return false
+    for (let j = 0; j < end[1]; j = j + 1) {
+      if (!Array.isArray(arr[i][j])) return false
+    }
+  }
+  return true
+}
+
+function checkForNumber(arr: any): boolean {
+  if (isArray(arr)) {
+    return arr.length > 0 && arr.filter(x => !checkForNumber(x)).length === 0
+  }
+
+  return typeof arr === 'number'
+}
+
+/*
+ * we only use the gpu if:
+ * 1. we are working with numbers
+ * 2. we have a large array (> 100 elements)
+ */
+function checkValidGPU(f: any, end: any): boolean {
+  let res: any
+  if (end.length === 1) res = f(0)
+  if (end.length === 2) res = f(0, 0)
+  if (end.length === 3) res = f(0, 0, 0)
+
+  if (typeof res !== 'number') {
+    if (!Array.isArray(res)) {
+      return false
+    }
+
+    if (!checkForNumber(res)) {
+      return false
+    }
+  }
+
+  let cnt = 1
+  for (const i of end) {
+    cnt = cnt * i
+  }
+
+  return cnt > MAX_SIZE
+}
+
+// just run on js!
+function manualRun(f: any, end: any, res: any) {
+  function build() {
+    for (let i = 0; i < end[0]; i++) {
+      res[i] = f(i)
+    }
+    return
+  }
+
+  function build2D() {
+    for (let i = 0; i < end[0]; i = i + 1) {
+      for (let j = 0; j < end[1]; j = j + 1) {
+        res[i][j] = f(i, j)
+      }
+    }
+    return
+  }
+
+  function build3D() {
+    for (let i = 0; i < end[0]; i = i + 1) {
+      for (let j = 0; j < end[1]; j = j + 1) {
+        for (let k = 0; k < end[2]; k = k + 1) {
+          res[i][j][k] = f(i, j, k)
+        }
+      }
+    }
+    return
+  }
+
+  if (end.length === 1) return build()
+  if (end.length === 2) return build2D()
+  return build3D()
+}
+
+/* main function that runs code on the GPU (using gpu.js library)
+ * @end : end bounds for array
+ * @extern : external variable definitions {}
+ * @f : function run as on GPU threads
+ * @arr : array to be written to
+ */
+export function __createKernel(end: any, extern: any, f: any, arr: any, f2: any) {
+  const gpu = new GPU()
+  const nend = []
+  for (let i = end.length - 1; i >= 0; i--) {
+    nend.push(end[i])
+  }
+
+  // check array is initialized properly
+  let ok = checkArray(arr)
+  let err = ''
+  if (!ok) {
+    err = typeof arr
+  }
+
+  // TODO: find a cleaner way to do this
+  if (end.length > 1) {
+    ok = ok && checkArray2D(arr, end)
+    if (!ok) {
+      err = 'undefined'
+    }
+  }
+
+  if (end.length > 2) {
+    ok = ok && checkArray3D(arr, end)
+    if (!ok) {
+      err = 'undefined'
+    }
+  }
+
+  if (!ok) {
+    throw new TypeError(arr, '', 'object or array', err)
+  }
+
+  // check if program is valid to run on GPU
+  ok = checkValidGPU(f2, end)
+  if (!ok) {
+    manualRun(f2, end, arr)
+    return
+  }
+
+  // external variables to be in the GPU
+  const out = { constants: {} }
+  out.constants = extern
+
+  const gpuFunction = gpu.createKernel(f, out).setOutput(nend)
+  const res = gpuFunction() as any
+  if (end.length === 1) buildArray(res, end, arr)
+  if (end.length === 2) build2DArray(res, end, arr)
+  if (end.length === 3) build3DArray(res, end, arr)
+}
@@ -0,0 +1,320 @@
+import * as es from 'estree'
+import { ancestor, simple, make } from 'acorn-walk/dist/walk'
+import * as create from '../utils/astCreator'
+import GPULoopVerifier from './verification/loopVerifier'
+import GPUBodyVerifier from './verification/bodyVerifier'
+
+/*
+ * GPU Transformer runs through the program and transpiles for loops to GPU code
+ * Upon termination, the AST would be mutated accordingly
+ * e.g.
+ * let res = 0;
+ * for (let i = 0; i < 5; i = i + 1) {
+ *    res[i] = 5;
+ * }
+ * would become:
+ * let res = 0;
+ * __createKernel(....)
+ */
+class GPUTransformer {
+  // program to mutate
+  program: es.Program
+
+  // helps reference the main function
+  static globalIds = {
+    __createKernel: create.identifier('__createKernel')
+  }
+
+  outputArray: es.Identifier
+  innerBody: any
+  counters: string[]
+  end: es.Expression[]
+  state: number
+  localVar: Set<string>
+  outerVariables: any
+  targetBody: any
+
+  constructor(program: es.Program) {
+    this.program = program
+  }
+
+  // transforms away top-level for loops if possible
+  transform = (): number[][] => {
+    const gpuTranspile = this.gpuTranspile
+    const res: number[][] = []
+
+    // tslint:disable
+    simple(
+      this.program,
+      {
+        ForStatement(node: es.ForStatement) {
+          let state = gpuTranspile(node)
+          if (state > 0 && node.loc) {
+            res.push([node.loc.start.line, state])
+          }
+        }
+      },
+      make({ ForStatement: () => {} })
+    )
+    // tslint:enable
+
+    return res
+  }
+
+  /*
+   * Here we transpile away a for loop:
+   * 1. Check if it meets our specifications
+   * 2. Get external variables + target body (body to be run across gpu threads)
+   * 3. Build a AST Node for (2) - this will be given to (8)
+   * 4. Change assignment in body to a return statement
+   * 5. In body, update all math_* calls to become Math.* calls
+   * 6. In body, update all external variable references
+   * 7. In body, update reference to counters
+   * 8. Call __createKernel and assign it to our external variable
+   */
+  gpuTranspile = (node: es.ForStatement): number => {
+    // initialize our class variables
+    this.state = 0
+    this.counters = []
+    this.end = []
+
+    // 1. verification of outer loops + body
+    this.checkOuterLoops(node)
+    // no gpu loops found
+    if (this.counters.length === 0 || new Set(this.counters).size !== this.counters.length) {
+      return 0
+    }
+
+    const verifier = new GPUBodyVerifier(this.program, this.innerBody, this.counters)
+    if (verifier.state === 0) {
+      return 0
+    }
+
+    this.state = verifier.state
+    this.outputArray = verifier.outputArray
+    this.localVar = verifier.localVar
+
+    // 2. get external variables + the main body
+    this.getOuterVariables()
+    this.getTargetBody(node)
+
+    // 3. Build a AST Node of all outer variables
+    const externObject: es.Property[] = []
+    for (const key in this.outerVariables) {
+      if (this.outerVariables.hasOwnProperty(key)) {
+        const val = this.outerVariables[key]
+
+        // push in a deep copy of the identifier
+        // this is needed cos we modify it later
+        externObject.push(create.property(key, JSON.parse(JSON.stringify(val))))
+      }
+    }
+
+    // 4. Change assignment in body to a return statement
+    const checker = verifier.getArrayName
+    const locals = this.localVar
+    ancestor(this.targetBody, {
+      AssignmentExpression(nx: es.AssignmentExpression, ancstor: es.Node[]) {
+        // assigning to local val, it's okay
+        if (nx.left.type === 'Identifier') {
+          return
+        }
+
+        if (nx.left.type !== 'MemberExpression') {
+          return
+        }
+
+        const id = checker(nx.left)
+        if (locals.has(id.name)) {
+          return
+        }
+
+        const sz = ancstor.length
+        create.mutateToReturnStatement(ancstor[sz - 2], nx.right)
+      }
+    })
+
+    // deep copy here (for runtime checks)
+    const params: es.Identifier[] = []
+    for (let i = 0; i < this.state; i++) {
+      params.push(create.identifier(this.counters[i]))
+    }
+    const tempNode = create.functionExpression(params, JSON.parse(JSON.stringify(this.targetBody)))
+
+    // 5. Update all math_* calls to become Math.*
+    simple(this.targetBody, {
+      CallExpression(nx: es.CallExpression) {
+        if (nx.callee.type !== 'Identifier') {
+          return
+        }
+
+        const functionName = nx.callee.name
+        const term = functionName.split('_')[1]
+        const args: es.Expression[] = nx.arguments as any
+
+        create.mutateToCallExpression(
+          nx,
+          create.memberExpression(create.identifier('Math'), term),
+          args
+        )
+      }
+    })
+
+    // 6. Update all external variable references in body
+    // e.g. let res = 1 + y; where y is an external variable
+    // becomes let res = 1 + this.constants.y;
+
+    const names = [this.outputArray.name, ...this.counters, 'Math']
+    simple(this.targetBody, {
+      Identifier(nx: es.Identifier) {
+        // ignore these names
+        if (names.includes(nx.name) || locals.has(nx.name)) {
+          return
+        }
+
+        create.mutateToMemberExpression(
+          nx,
+          create.memberExpression(create.identifier('this'), 'constants'),
+          create.identifier(nx.name)
+        )
+      }
+    })
+
+    // 7. Update reference to counters
+    // e.g. let res = 1 + i; where i is a counter
+    // becomes let res = 1 + this.thread.x;
+
+    // depending on state the mappings will change
+    let threads = ['x']
+    if (this.state === 2) threads = ['y', 'x']
+    if (this.state === 3) threads = ['z', 'y', 'x']
+
+    const counters: string[] = []
+    for (let i = 0; i < this.state; i = i + 1) {
+      counters.push(this.counters[i])
+    }
+
+    simple(this.targetBody, {
+      Identifier(nx: es.Identifier) {
+        let x = -1
+        for (let i = 0; i < counters.length; i = i + 1) {
+          if (nx.name === counters[i]) {
+            x = i
+            break
+          }
+        }
+
+        if (x === -1) {
+          return
+        }
+
+        const id = threads[x]
+        create.mutateToMemberExpression(
+          nx,
+          create.memberExpression(create.identifier('this'), 'thread'),
+          create.identifier(id)
+        )
+      }
+    })
+
+    // 8. we transpile the loop to a function call, __createKernel
+    const kernelFunction = create.functionExpression([], this.targetBody)
+    create.mutateToExpressionStatement(
+      node,
+      create.callExpression(
+        GPUTransformer.globalIds.__createKernel,
+        [
+          create.arrayExpression(this.end),
+          create.objectExpression(externObject),
+          kernelFunction,
+          this.outputArray,
+          tempNode
+        ],
+        node.loc!
+      )
+    )
+
+    return this.state
+  }
+
+  // verification of outer loops using our verifier
+  checkOuterLoops = (node: es.ForStatement) => {
+    let currForLoop = node
+    while (currForLoop.type === 'ForStatement') {
+      const detector = new GPULoopVerifier(currForLoop)
+      if (!detector.ok) {
+        break
+      }
+
+      this.innerBody = currForLoop.body
+      this.counters.push(detector.counter)
+      this.end.push(detector.end)
+
+      if (this.innerBody.type !== 'BlockStatement') {
+        break
+      }
+
+      if (this.innerBody.body.length > 1 || this.innerBody.body.length === 0) {
+        break
+      }
+
+      currForLoop = this.innerBody.body[0]
+    }
+  }
+
+  /*
+   * Based on state, gets the correct body to be run across threads
+   * e.g. state = 2 (2 top level loops skipped)
+   * for (...) {
+   *    for (...) {
+   *      let x = 1;
+   *      res[i] = x + 1
+   *    }
+   * }
+   *
+   * returns:
+   *
+   * {
+   *  let x = 1;
+   *  res[i] = x + 1
+   * }
+   */
+  getTargetBody(node: es.ForStatement) {
+    let mv = this.state
+    this.targetBody = node
+    while (mv > 1) {
+      this.targetBody = this.targetBody.body.body[0]
+      mv--
+    }
+    this.targetBody = this.targetBody.body
+  }
+
+  // get all variables defined outside the block (on right hand side)
+  // TODO: method can be more optimized
+  getOuterVariables() {
+    // set some local variables for walking
+    const curr = this.innerBody
+    const localVar = this.localVar
+    const counters = this.counters
+    const output = this.outputArray.name
+
+    const varDefinitions = {}
+    simple(curr, {
+      Identifier(node: es.Identifier) {
+        if (
+          localVar.has(node.name) ||
+          counters.includes(node.name) ||
+          node.name === output ||
+          node.name.startsWith('math_')
+        ) {
+          return
+        }
+
+        varDefinitions[node.name] = node
+      }
+    })
+    this.outerVariables = varDefinitions
+  }
+}
+
+export default GPUTransformer
@@ -0,0 +1,211 @@
+import * as es from 'estree'
+import { simple, make } from 'acorn-walk/dist/walk'
+
+/*
+ * GPU Body verifier helps to ensure the body is parallelizable
+ * It does a series of checks to make sure the loop can be parallelized easily
+ * Upon termination will update:
+ *   @state: number that indicates the dimensions you can parallize till (max 3)
+ *   @localVar: local variables in the body
+ *   @outputArray: array that is being written to
+ */
+class GPUBodyVerifier {
+  program: es.Program
+  node: es.Statement
+
+  state: number
+  localVar: Set<string>
+  counters: string[]
+  outputArray: es.Identifier
+
+  /**
+   *
+   * @param node body to be verified
+   * @param counters list of for loop counters (to check array assignment)
+   */
+  constructor(program: es.Program, node: es.Statement, counters: string[]) {
+    this.program = program
+    this.node = node
+    this.counters = counters
+    this.state = 0
+    this.checkBody(node)
+  }
+
+  /*
+   * Checks if the GPU body is valid
+   * 1. No return/function declarations/break/continue
+   * 2. No functions except math_*
+   * 3. Only ONE assignment to a global result variable
+   * 4. Assigning to an array at specific indices (i, j, k from for loop counters)
+   */
+  checkBody = (node: es.Statement) => {
+    let ok: boolean = true
+
+    // 1. check illegal statements
+    simple(node, {
+      FunctionDeclaration() {
+        ok = false
+      },
+      ArrowFunctionExpression() {
+        ok = false
+      },
+      ReturnStatement() {
+        ok = false
+      },
+      BreakStatement() {
+        ok = false
+      },
+      ContinueStatement() {
+        ok = false
+      }
+    })
+
+    if (!ok) {
+      return
+    }
+
+    // 2. check function calls are only to math_*
+    const mathFuncCheck = new RegExp(/^math_[a-z]+$/)
+    simple(node, {
+      CallExpression(nx: es.CallExpression) {
+        if (nx.callee.type !== 'Identifier') {
+          ok = false
+          return
+        }
+
+        const functionName = nx.callee.name
+        if (!mathFuncCheck.test(functionName)) {
+          ok = false
+          return
+        }
+      }
+    })
+
+    if (!ok) {
+      return
+    }
+
+    // 3. check there is only ONE assignment to a global result variable
+
+    // get all local variables
+    const localVar = new Set<string>()
+    simple(node, {
+      VariableDeclaration(nx: es.VariableDeclaration) {
+        if (nx.declarations[0].id.type === 'Identifier') {
+          localVar.add(nx.declarations[0].id.name)
+        }
+      }
+    })
+    this.localVar = localVar
+
+    // make sure only one assignment
+    const resultExpr: es.AssignmentExpression[] = []
+    const checker = this.getArrayName
+    simple(node, {
+      AssignmentExpression(nx: es.AssignmentExpression) {
+        // assigning to local val, it's okay
+        if (nx.left.type === 'Identifier' && localVar.has(nx.left.name)) {
+          return
+        }
+
+        if (nx.left.type === 'MemberExpression') {
+          const chk = checker(nx.left)
+          if (localVar.has(chk.name)) {
+            return
+          }
+        }
+
+        resultExpr.push(nx)
+      }
+    })
+
+    // too many assignments!
+    if (resultExpr.length !== 1) {
+      return
+    }
+
+    // 4. check assigning to array at specific indices
+
+    // not assigning to array
+    if (resultExpr[0].left.type !== 'MemberExpression') {
+      return
+    }
+
+    // check res assignment and its counters
+    const res = this.getPropertyAccess(resultExpr[0].left)
+    if (res.length === 0 || res.length > this.counters.length) {
+      return
+    }
+
+    // check result variable is not used anywhere with wrong indices
+    const getProp = this.getPropertyAccess
+    const resArr = this.outputArray
+    simple(
+      node,
+      {
+        MemberExpression(nx: es.MemberExpression) {
+          const chk = checker(nx)
+          if (chk.name !== resArr.name) {
+            return
+          }
+
+          // get indices
+          const indices = getProp(nx)
+          if (JSON.stringify(indices) === JSON.stringify(res)) {
+            return
+          }
+
+          ok = false
+        }
+      },
+      // tslint:disable-next-line
+      make({ MemberExpression: () => {} })
+    )
+
+    if (!ok) {
+      return
+    }
+
+    for (let i = 0; i < this.counters.length; i++) {
+      if (res[i] !== this.counters[i]) break
+      this.state++
+    }
+
+    // we only can have upto 3 states
+    if (this.state > 3) this.state = 3
+  }
+
+  getArrayName = (node: es.MemberExpression): es.Identifier => {
+    let curr: any = node
+    while (curr.type === 'MemberExpression') {
+      curr = curr.object
+    }
+    return curr
+  }
+
+  // helper function that helps to get indices accessed from array
+  // e.g. returns i, j for res[i][j]
+  getPropertyAccess = (node: es.MemberExpression): string[] => {
+    const res: string[] = []
+    let ok: boolean = true
+    let curr: any = node
+    while (curr.type === 'MemberExpression') {
+      if (curr.property.type !== 'Identifier') {
+        ok = false
+        break
+      }
+
+      res.push(curr.property.name)
+      curr = curr.object
+    }
+
+    if (!ok) {
+      return []
+    }
+
+    this.outputArray = curr
+    return res.reverse()
+  }
+}
+
+export default GPUBodyVerifier
@@ -0,0 +1,131 @@
+import * as es from 'estree'
+
+/*
+ * Loop Detector helps to verify if a for loop can be parallelized with a GPU
+ * Updates ok, counter and end upon termination
+ * @ok: false if not valid, true of valid
+ * @end: if valid, stores the end of the loop
+ * @counter: stores the string representation of the counter
+ */
+class GPULoopVerifier {
+  // for loop that we are looking at
+  node: es.ForStatement
+
+  counter: string
+  end: es.Expression
+  ok: boolean
+
+  constructor(node: es.ForStatement) {
+    this.node = node
+    this.forLoopTransform(this.node)
+  }
+
+  forLoopTransform = (node: es.ForStatement) => {
+    if (!node.init || !node.update || !node.test) {
+      return
+    }
+
+    this.ok =
+      this.hasCounter(node.init) && this.hasCondition(node.test) && this.hasUpdate(node.update)
+  }
+
+  /*
+   * Checks if the loop counter is valid
+   * it has to be "let <identifier> = 0;"
+   */
+  hasCounter = (node: es.VariableDeclaration | es.Expression | null): boolean => {
+    if (!node || node.type !== 'VariableDeclaration') {
+      return false
+    }
+
+    if (node.kind !== 'let') {
+      return false
+    }
+
+    const declaration: es.VariableDeclarator[] = node.declarations
+    if (declaration.length > 1) {
+      return false
+    }
+
+    const initializer: es.VariableDeclarator = declaration[0]
+    if (initializer.id.type !== 'Identifier' || !initializer.init) {
+      return false
+    }
+
+    this.counter = initializer.id.name
+
+    const set: es.Expression = initializer.init
+    if (!set || set.type !== 'Literal' || set.value !== 0) {
+      return false
+    }
+
+    return true
+  }
+
+  /*
+   * Checks if the loop condition is valid
+   * it has to be "<identifier> < <number>;"
+   * identifier is the same as the one initialized above
+   */
+  hasCondition = (node: es.Expression): boolean => {
+    if (node.type !== 'BinaryExpression') {
+      return false
+    }
+
+    if (!(node.operator === '<' || node.operator === '<=')) {
+      return false
+    }
+
+    const lv: es.Expression = node.left
+    if (lv.type !== 'Identifier' || lv.name !== this.counter) {
+      return false
+    }
+
+    const rv = node.right
+    if (!(rv.type === 'Identifier' || rv.type === 'Literal')) {
+      return false
+    }
+
+    this.end = rv
+    return true
+  }
+
+  /*
+   * Checks if the loop update is valid
+   * it has to be "<identifier> = <identifier> + 1;"
+   * identifier is the same as the one initialized above
+   */
+  hasUpdate = (node: es.Expression): boolean => {
+    if (node.type !== 'AssignmentExpression') {
+      return false
+    }
+
+    if (node.operator !== '=') {
+      return false
+    }
+
+    if (node.left.type !== 'Identifier' || node.left.name !== this.counter) {
+      return false
+    }
+
+    if (node.right.type !== 'BinaryExpression') {
+      return false
+    }
+
+    const rv = node.right
+    if (rv.operator !== '+') {
+      return false
+    }
+
+    const identifierLeft = rv.left.type === 'Identifier' && rv.left.name === this.counter
+    const identifierRight = rv.right.type === 'Identifier' && rv.right.name === this.counter
+
+    const literalLeft = rv.left.type === 'Literal' && rv.left.value === 1
+    const literalRight = rv.right.type === 'Literal' && rv.right.value === 1
+
+    // we allow both i = i + 1 and i = 1 + i
+    return (identifierLeft && literalRight) || (identifierRight && literalLeft)
+  }
+}
+
+export default GPULoopVerifier
@@ -57,7 +57,7 @@ export interface Comment {
 }
 
 export type ExecutionMethod = 'native' | 'interpreter' | 'auto'
-export type Variant = 'wasm' | 'lazy' | 'non-det' | 'concurrent' | 'default' // this might replace EvaluationMethod
+export type Variant = 'wasm' | 'lazy' | 'non-det' | 'concurrent' | 'gpu' | 'default' // this might replace EvaluationMethod
 
 export interface Context<T = any> {
   /** The source version used */
 
@@ -138,6 +138,42 @@ export const mutateToCallExpression = (
   node.arguments = args
 }
 
+export const mutateToAssignmentExpression = (
+  node: es.Node,
+  left: es.Pattern,
+  right: es.Expression
+) => {
+  node.type = 'AssignmentExpression'
+  node = node as es.AssignmentExpression
+  node.operator = '='
+  node.left = left
+  node.right = right
+}
+
+export const mutateToExpressionStatement = (node: es.Node, expr: es.Expression) => {
+  node.type = 'ExpressionStatement'
+  node = node as es.ExpressionStatement
+  node.expression = expr
+}
+
+export const mutateToReturnStatement = (node: es.Node, expr: es.Expression) => {
+  node.type = 'ReturnStatement'
+  node = node as es.ReturnStatement
+  node.argument = expr
+}
+
+export const mutateToMemberExpression = (
+  node: es.Node,
+  obj: es.Expression,
+  prop: es.Expression
+) => {
+  node.type = 'MemberExpression'
+  node = node as es.MemberExpression
+  node.object = obj
+  node.property = prop
+  node.computed = false
+}
+
 export const logicalExpression = (
   operator: es.LogicalOperator,
   left: es.Expression,
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ export interface Comment {`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`export type ExecutionMethod = 'native' \| 'interpreter' \| 'auto'`
`60`		`-export type Variant = 'wasm' \| 'lazy' \| 'non-det' \| 'concurrent' \| 'default' // this might replace EvaluationMethod`
	`60`	`+export type Variant = 'wasm' \| 'lazy' \| 'non-det' \| 'concurrent' \| 'gpu' \| 'default' // this might replace EvaluationMethod`
`61`	`61`
`62`	`62`	`export interface Context<T = any> {`
`63`	`63`	`/** The source version used */`