diff --git a/bin/main b/bin/main
index 48d6cca..5dc5e89 100755
Binary files a/bin/main and b/bin/main differ
diff --git a/in/simple.asl b/in/simple.asl
index 084b82e..8bcb251 100644
--- a/in/simple.asl
+++ b/in/simple.asl
@@ -1,2 +1,9 @@
-var a = 1;
-var b = 2;
+var _a = 1;
+var _b = 2;
+
+if _a < _b {
+    var _x = 5;
+}
+else{
+    var _x = 6;
+}
diff --git a/pkg/linux_amd64/asl.a b/pkg/linux_amd64/asl.a
index e41b4a0..385d801 100644
Binary files a/pkg/linux_amd64/asl.a and b/pkg/linux_amd64/asl.a differ
diff --git a/src/asl/parser.go b/src/asl/parser.go
index b9e061d..311ded9 100644
--- a/src/asl/parser.go
+++ b/src/asl/parser.go
@@ -1,7 +1,129 @@
 package asl
 
 import (
-
+    
 )
 
+const TAB = "    "
 
+var tokens []Token
+var tokenIndex int
+var out string
+var offset int
+
+func Parse(token []Token) string {
+    initParser(token)
+    
+    for tokenIndex < len(token) {
+        parseBlock()
+    }
+    
+    return out
+}
+
+// parser functions
+
+func parseBlock() {
+    if get().token == "var" {
+        parseVar()
+    } else if get().token == "if" {
+        parseIf()
+    } else {
+        parseStatement()
+    }
+}
+
+func parseVar() {
+    expect("var")
+    appendOut(get().token)
+    next()
+    
+    if accept("=") {
+        next()
+        appendOut(" = "+get().token)
+        next()
+    }
+    
+    appendOut(";\n")
+    expect(";")
+}
+
+func parseIf() {
+    expect("if")
+    appendOut("if (")
+    parseCondition()
+    appendOut(") then {\n")
+    expect("{")
+    parseBlock()
+    expect("}")
+    
+    if accept("else") {
+        next()
+        expect("{")
+        appendOut("} else {\n")
+        parseBlock()
+        expect("}")
+    }
+    
+    appendOut("};")
+}
+
+func parseCondition() {
+    for get().token != "{" {
+        appendOut(get().token)
+        next()
+        
+        if get().token != "{" {
+            appendOut(" ")
+        }
+    }
+}
+
+func parseStatement() {
+    
+}
+
+// helper functions
+
+func initParser(token []Token) {
+    if len(token) == 0 {
+        panic("No tokens provided")
+    }
+    
+    tokens = token
+    tokenIndex = 0
+    out = ""
+    offset = 0
+}
+
+func accept(token string) bool {
+    return tokenEqual(token, get())
+}
+
+func expect(token string) {
+    if !tokenEqual(token, get()) {
+        panic("Parse error, expected '"+token+"' but was '"+get().token+"'")
+    }
+    
+    next()
+}
+
+func next() {
+    tokenIndex++
+}
+
+func get() Token {
+    if tokenIndex >= len(tokens) {
+        panic("No more tokens")
+    }
+    
+    return tokens[tokenIndex]
+}
+
+func tokenEqual(a string, b Token) bool {
+    return a == b.token
+}
+
+func appendOut(str string) {
+    out += str
+}
diff --git a/src/asl/tokenizer.go b/src/asl/tokenizer.go
index 73fa91c..a1ec600 100644
--- a/src/asl/tokenizer.go
+++ b/src/asl/tokenizer.go
@@ -8,8 +8,17 @@ type Token struct{
     token string
 }
 
-var delimiter = []byte{'=', ';'}
-var keywords = []string{"var"}
+var delimiter = []byte{'=',
+    ';',
+    '{',
+    '}',
+    '<',
+    '>',
+    '!'}
+
+var keywords = []string{"var",
+    "if"}
+
 var whitespace = []byte{' ', '\n', '\t'}
 
 func Tokenize(code []byte) []Token {
@@ -20,7 +29,10 @@ func Tokenize(code []byte) []Token {
         c := code[i]
         
         if byteArrayContains(delimiter, c) {
-            tokens = append(tokens, Token{token})
+            if token != "" {
+                tokens = append(tokens, Token{token})
+            }
+            
             tokens = append(tokens, Token{string(c)})
             token = ""
         } else if stringArrayContains(keywords, token) {
@@ -32,9 +44,11 @@ func Tokenize(code []byte) []Token {
     }
     
     // TEST
+    fmt.Println("Tokens:")
     for i := range tokens {
         fmt.Println(tokens[i].token)
     }
+    fmt.Println("---")
     
     return tokens
 }
diff --git a/src/main/asl.go b/src/main/asl.go
index 5398f5a..59dbe20 100644
--- a/src/main/asl.go
+++ b/src/main/asl.go
@@ -3,10 +3,14 @@ package main
 import (
     "io/ioutil"
     "asl"
+    "fmt"
 )
 
 func main(){
     // read test file
     code, _ := ioutil.ReadFile("in/simple.asl")
-    asl.Tokenize(code)
+    token := asl.Tokenize(code)
+    out := asl.Parse(token)
+    
+    fmt.Println(out)
 }