diff --git a/AmogulatorVM.cs b/AmogulatorVM.cs
index cd89959..d2422ac 100644
--- a/AmogulatorVM.cs
+++ b/AmogulatorVM.cs
@@ -1,9 +1,22 @@
-using CommunityToolkit.Mvvm.ComponentModel;
+using Amogulator.Suslang;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
 
 namespace Amogulator;
 public partial class AmogulatorVM : ObservableObject {
 
     [ObservableProperty]
-    private string output = "test";
+    private string output = "test", input = "2 + 3";
+
+    [RelayCommand]
+    private void run() {
+        var ast = new Parser(this.Input, new Lexer(this.Input)).parseExpr();
+        var compiler = new Compiler();
+        compiler.compileExpr(ast);
+        var bytecode = compiler.result();
+        var vm = new VM(bytecode);
+        vm.evaluate();
+        this.Output = ast.astString(0) + "\n\nresult = " + ((IntValue) vm.stack.Peek()).value;
+    }
 
 }
diff --git a/MainWindow.xaml b/MainWindow.xaml
index 6df8fbd..b4b8011 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -5,6 +5,7 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:vm="clr-namespace:Amogulator"
         mc:Ignorable="d"
+        Background="Black"
         Title="MainWindow" Height="450" Width="800">
     <Window.Resources>
         <vm:AmogulatorVM x:Key="ViewModel" />
@@ -15,7 +16,7 @@
         </Grid.ColumnDefinitions>
         <Grid.RowDefinitions>
             <RowDefinition Height="4*" />
-            <RowDefinition Height="4*" />
+            <RowDefinition Height="2*" />
             <RowDefinition Height="*" />
         </Grid.RowDefinitions>
         <Label
@@ -24,19 +25,26 @@
             Content="{Binding Output}"
             Margin="5"
             FontSize="16"
-            FontFamily="Consolas"
+            FontFamily="Consolas monospace"
+            Background="Black"
+            Foreground="White"
+            ScrollViewer.CanContentScroll="True"
         />
         <TextBox
             Grid.Column="0"
             Grid.Row="1"
+            Text="{Binding Input}"
             Margin="5"
             FontSize="16"
-            FontFamily="Consolas"
+            FontFamily="Consolas monospace"
+            Background="Black"
+            Foreground="White"
         />
         <Button
             Grid.Column="0"
             Grid.Row="2"
             Grid.ColumnSpan="1"
+            Command="{Binding runCommand}"
             Content="Test"
             Margin="5"
         />
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 947049e..a476c30 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -21,4 +21,8 @@ public partial class MainWindow : Window {
     public MainWindow() {
         InitializeComponent();
     }
+
+    private void Label_Scroll(object sender, System.Windows.Controls.Primitives.ScrollEventArgs e) {
+
+    }
 }
diff --git a/Suslang/Suslang.cs b/Suslang/Suslang.cs
index 4b448ff..0507e8f 100644
--- a/Suslang/Suslang.cs
+++ b/Suslang/Suslang.cs
@@ -73,7 +73,7 @@ public class Lexer {
         step();
         while (!done() && "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".Contains(current()))
             step();
-        this.text.Substring(start.index, this.i - start.index).switch {
+        return this.text.Substring(start.index, this.i - start.index) switch {
             "false" => token(TokenType.False, start),
             "true" => token(TokenType.True, start),
             _ => token(TokenType.Id, start),
@@ -84,9 +84,9 @@ public class Lexer {
         var start = position();
         switch (current()) {
             case '0':
-                break;
+                return zeroToken();
             case '.':
-                break;
+                return dotToken();
             case '(':
                 step();
                 return token(TokenType.LParen, start);
@@ -118,21 +118,21 @@ public class Lexer {
         var start = position();
         step();
         if (!done() && (current() == 'x' || current() == 'X')) {
-            while (!done() && "1234567890abcdefABCDEF".Contains(current())) 
+            while (!done() && "1234567890abcdefABCDEF".Contains(current()))
                 step();
             return token(TokenType.Hex, start);
         } else {
-            while (!done() && "1234567890".Contains(current())) 
+            while (!done() && "1234567890".Contains(current()))
                 step();
             return token(TokenType.Int, start);
         }
     }
-    
+
     private Token dotToken() {
         var start = position();
         step();
         if (!done() && "1234567890".Contains(current())) {
-            while (!done() && "1234567890".Contains(current())) 
+            while (!done() && "1234567890".Contains(current()))
                 step();
             return token(TokenType.Decimal, start);
         } else {
@@ -157,6 +157,14 @@ public class Lexer {
 
     private void step() {
         this.i += 1;
+        if (!done()) {
+            if (current() == '\n') {
+                this.line += 1;
+                this.col = 1;
+            } else {
+                this.col += 1;
+            }
+        }
     }
 }
 
@@ -164,46 +172,46 @@ public interface Expr {
     string astString(int depth);
 }
 
-public ErrorExpr : Expr {
+public class ErrorExpr : Expr {
     public Position position;
     public string message;
 
-    public override astString(int depth) =>
+    public string astString(int depth) =>
         $"ErrorExpr {{ {this.position.line}:{this.position.col} \"{this.message}\" }}";
 }
 
-public IdExpr : Expr {
+public class IdExpr : Expr {
     public string value;
 
-    public override astString(int depth) =>
+    public string astString(int depth) =>
         $"IdExpr {{ \"{this.value}\" }}";
 }
 
-public IntExpr : Expr {
+public class IntExpr : Expr {
     public int value;
 
-    public override astString(int depth) =>
+    public string astString(int depth) =>
         $"IntExpr {{ {this.value} }}";
 }
 
-public FloatExpr : Expr {
+public class FloatExpr : Expr {
     public double value;
 
-    public override astString(int depth) =>
+    public string astString(int depth) =>
         $"FloatExpr {{ {this.value} }}";
 }
 
-public StringExpr : Expr {
+public class StringExpr : Expr {
     public string value;
 
-    public override astString(int depth) =>
+    public string astString(int depth) =>
         $"FloatExpr {{ \"{this.value}\" }}";
 }
 
-public BoolExpr : Expr {
+public class BoolExpr : Expr {
     public bool value;
 
-    public override astString(int depth) =>
+    public string astString(int depth) =>
         $"BoolExpr {{ {this.value} }}";
 }
 
@@ -212,13 +220,13 @@ public enum UnaryType {
     Negate,
 }
 
-public UnaryExpr : Expr {
+public class UnaryExpr : Expr {
     public UnaryType type;
     public Expr value;
 
-    public override astString(int depth) =>
-        $"UnaryExpr {{\n{new String(' ', depth) + 1}type: "
-        + $"{this.type.ToString()},\n{new String(' ', depth + 1)}value: "
+    public string astString(int depth) =>
+        $"UnaryExpr {{\n{new string(' ', depth + 1)}type: "
+        + $"{this.type},\n{new string(' ', depth + 1)}value: "
         + $"{this.value.astString(depth + 1)}\n{new String(' ', depth)}}}";
 }
 
@@ -227,28 +235,29 @@ public enum BinaryType {
     Subtract,
     Multiply,
     Divide,
-    Modulus,
+    Modulo,
 }
 
-public BinaryExpr : Expr {
+public class BinaryExpr : Expr {
     public BinaryType type;
     public Expr left, right;
 
-    public override astString(int depth) =>
-        $"UnaryExpr {{\n{new String(' ', depth) + 1}type: "
+    public string astString(int depth) =>
+        $"BinaryExpr {{\n{new String(' ', depth + 1)}type: "
         + $"{this.type.ToString()},\n{new String(' ', depth + 1)}left: "
         + $"{this.left.astString(depth + 1)},\n{new String(' ', depth + 1)}right: "
-        + $"{this.right.astString(depth + 1)}\n{new String(' ', depth)}}}";
+        + $"{this.right.astString(depth + 1)},\n{new String(' ', depth)}}}";
 }
 
 public class Parser {
-    private int i = 0;
     private string text;
-    private List<Token> tokens;
+    private Lexer lexer;
+    private Token currentToken;
 
-    public Parser(string text, List<Token> tokens) {
+    public Parser(string text, Lexer lexer) {
         this.text = text;
-        this.tokens = tokens;
+        this.lexer = lexer;
+        this.currentToken = this.lexer.next();
     }
 
     public Expr parseExpr() {
@@ -269,7 +278,7 @@ public class Parser {
             step();
             var right = parsePrec11();
             return new BinaryExpr() {
-                type = BinaryType.Subtraction,
+                type = BinaryType.Subtract,
                 left = left,
                 right = right,
             };
@@ -282,7 +291,7 @@ public class Parser {
         var left = parsePrec13();
         if (!done() && current().type == TokenType.Asterisk) {
             step();
-            var right = parePrec12();
+            var right = parsePrec12();
             return new BinaryExpr() {
                 type = BinaryType.Multiply,
                 left = left,
@@ -290,7 +299,7 @@ public class Parser {
             };
         } else if (!done() && current().type == TokenType.Slash) {
             step();
-            var right = parePrec12();
+            var right = parsePrec12();
             return new BinaryExpr() {
                 type = BinaryType.Divide,
                 left = left,
@@ -298,9 +307,9 @@ public class Parser {
             };
         } else if (!done() && current().type == TokenType.Percent) {
             step();
-            var right = parePrec12();
+            var right = parsePrec12();
             return new BinaryExpr() {
-                type = BinaryType.Modulus,
+                type = BinaryType.Modulo,
                 left = left,
                 right = right,
             };
@@ -317,7 +326,7 @@ public class Parser {
         if (!done() && current().type == TokenType.LParen) {
             step();
             var expr = parseExpr();
-            if (done() || current().type TokenType.RParen) {
+            if (done() || current().type != TokenType.RParen) {
                 var pos = position();
                 step();
                 return new ErrorExpr() {
@@ -332,13 +341,13 @@ public class Parser {
         }
     }
 
-    public parseOperand() {
+    public Expr parseOperand() {
         var start = position();
         if (done()) {
             step();
             return new ErrorExpr() {
                 position = start,
-                message = "expected value, got eof",
+                message = "expected value, got Eof",
             };
         } else if (current().type == TokenType.Int) {
             var intToken = current();
@@ -347,13 +356,19 @@ public class Parser {
                 var decimalToken = current();
                 step();
                 return new FloatExpr() {
-                    value = double.Parse(this.text.Substring(start.index, intToken.length + decimalToken.length)),
+                    value = double.Parse(this.text.Substring(start.index, intToken.length + decimalToken.length).Replace(".", ",")),
                 };
             } else {
                 return new IntExpr() {
-                    value = int.Parse(this.text.Substring(start.index, intToken.length));
+                    value = int.Parse(this.text.Substring(start.index, intToken.length)),
                 };
             }
+        } else if (current().type == TokenType.Decimal) {
+            var decimalToken = current();
+            step();
+            return new FloatExpr() {
+                value = double.Parse("0" + this.text.Substring(start.index, decimalToken.length).Replace(".", ",")),
+            };
         } else if (current().type == TokenType.String) {
             var stringToken = current();
             step();
@@ -379,34 +394,182 @@ public class Parser {
         }
     }
 
-    private char current() => this.tokens[this.i];
-    private bool done() => this.i >= this.text.Length;
+    private Position position() => current().position;
+    private Token current() => this.currentToken;
+    private bool done() => this.currentToken.type == TokenType.Eof;
 
     private void step() {
-        this.i += 1;
+        this.currentToken = this.lexer.next();
     }
 }
 
-public interface Operation {}
+public interface Operation { }
 
-public class PushInt {
+public class PushIntOperation : Operation {
     public int value;
-} 
+}
 
-public class PushFloat {
+public class PushFloatOperation : Operation {
     public double value;
 }
 
+public class PushStringOperation : Operation {
+    public string value;
+}
+
+public class PushBoolOperation : Operation {
+    public bool value;
+}
+
+public class AddIntOperation : Operation { }
+public class SubtractIntOperation : Operation { }
+public class MultiplyIntOperation : Operation { }
+public class DivideIntOperation : Operation { }
+public class ModuloIntOperation : Operation { }
+public class AddFloatOperation : Operation { }
+public class SubtractFloatOperation : Operation { }
+public class MultiplyFloatOperation : Operation { }
+public class DivideFloatOperation : Operation { }
+public class ModuloFloatOperation : Operation { }
+
 public class Compiler {
-    public List<Operation> compileExpr(Expr expr) {
+    private List<Operation> operations = new();
+
+    public List<Operation> result() => this.operations;
+
+    public string compileExpr(Expr expr) {
+        switch (expr) {
+            case IntExpr:
+                return compileIntExpr((IntExpr) expr);
+                break;
+            case FloatExpr:
+                return compileFloatExpr((FloatExpr) expr);
+                break;
+            case StringExpr:
+                return compileStringExpr((StringExpr) expr);
+                break;
+            case BoolExpr:
+                return compileBoolExpr((BoolExpr) expr);
+                break;
+            case UnaryExpr:
+                return compileUnaryExpr((UnaryExpr) expr);
+                break;
+            case BinaryExpr:
+                return compileBinaryExpr((BinaryExpr) expr);
+                break;
+            default:
+                throw new NotImplementedException();
+        };
+    }
+
+    public string compileIntExpr(IntExpr expr) {
+        this.operations.Add(new PushIntOperation() { value = expr.value });
+        return "int";
+    }
+
+    public string compileFloatExpr(FloatExpr expr) {
+        this.operations.Add(new PushFloatOperation() { value = expr.value });
+        return "float";
+    }
+
+    public string compileStringExpr(StringExpr expr) {
+        this.operations.Add(new PushStringOperation() { value = expr.value });
+        return "string";
+    }
+
+    public string compileBoolExpr(BoolExpr expr) {
+        this.operations.Add(new PushBoolOperation() { value = expr.value });
+        return "bool";
+    }
+
+    public string compileUnaryExpr(UnaryExpr expr) {
         throw new NotImplementedException();
     }
+
+    public string compileBinaryExpr(BinaryExpr expr) {
+        var leftType = compileExpr(expr.left);
+        var rightType = compileExpr(expr.right);
+        if ((leftType, rightType) == ("int", "int")) {
+            this.operations.Add(expr.type switch {
+                BinaryType.Add => new AddIntOperation(),
+                BinaryType.Subtract => new SubtractIntOperation(),
+                BinaryType.Multiply => new MultiplyIntOperation(),
+                BinaryType.Divide => new DivideIntOperation(),
+                BinaryType.Modulo => new ModuloIntOperation(),
+            });
+            return "int";
+        } else if ((leftType, rightType) == ("int", "int")) {
+            this.operations.Add(expr.type switch {
+                BinaryType.Add => new AddFloatOperation(),
+                BinaryType.Subtract => new SubtractFloatOperation(),
+                BinaryType.Multiply => new MultiplyFloatOperation(),
+                BinaryType.Divide => new DivideFloatOperation(),
+                BinaryType.Modulo => new ModuloFloatOperation(),
+            });
+            return "float";
+        } else {
+            throw new Exception("type mismatch");
+        }
+    }
 }
 
 public interface Value { }
 
+public class IntValue : Value { public int value; }
+public class FloatValue : Value { public double value; }
+
 public class VM {
-    public Value evaluate(List<Operation> program) {
-        throw new NotImplementedException();
+    private int pc = 0;
+    private List<Operation> program;
+    public Stack<Value> stack = new();
+
+    public VM(List<Operation> program) {
+        this.program = program;
+    }
+
+    public void evaluate() {
+        while (this.pc < this.program.Count) {
+            switch (this.program[this.pc]) {
+                case PushIntOperation op:
+                    this.stack.Push(new IntValue() { value = op.value });
+                    break;
+                case PushFloatOperation op:
+                    this.stack.Push(new FloatValue() { value = op.value });
+                    break;
+                case AddIntOperation:
+                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value + ((IntValue) this.stack.Pop()).value });
+                    break;
+                case SubtractIntOperation:
+                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value - ((IntValue) this.stack.Pop()).value });
+                    break;
+                case MultiplyIntOperation:
+                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value * ((IntValue) this.stack.Pop()).value });
+                    break;
+                case DivideIntOperation:
+                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value / ((IntValue) this.stack.Pop()).value });
+                    break;
+                case ModuloIntOperation:
+                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value % ((IntValue) this.stack.Pop()).value });
+                    break;
+                case AddFloatOperation:
+                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value + ((FloatValue) this.stack.Pop()).value });
+                    break;
+                case SubtractFloatOperation:
+                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value - ((FloatValue) this.stack.Pop()).value });
+                    break;
+                case MultiplyFloatOperation:
+                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value * ((FloatValue) this.stack.Pop()).value });
+                    break;
+                case DivideFloatOperation:
+                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value / ((FloatValue) this.stack.Pop()).value });
+                    break;
+                case ModuloFloatOperation:
+                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value % ((FloatValue) this.stack.Pop()).value });
+                    break;
+                default:
+                    break;
+            }
+            this.pc += 1;
+        }
     }
 }