diff --git a/src/main.c b/src/main.c
index 95a5a37..d401d2d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -51,10 +51,10 @@ int main(int argc, char **argv) {
 
   initTokenMap();
   compile(vm.memory, buffer);
-  vm.frame_stack_size = FRAME_STACK_SIZE;
-  vm.return_stack_size = RETURN_STACK_SIZE;
+  vm.frames_size = FRAMES_SIZE;
+  vm.stack_size = STACK_SIZE;
   vm.memory_size = MEMORY_SIZE;
-  vm.frame_stack[vm.fp].allocated.end = demo_add_compile(vm.memory);
+  vm.frames[vm.fp].allocated.end = demo_add_compile(vm.memory);
 
 #ifdef __EMSCRIPTEN__
   emscripten_set_main_loop(mainloop, 0, 1);
diff --git a/src/opcodes.h b/src/opcodes.h
index 842761b..197134b 100644
--- a/src/opcodes.h
+++ b/src/opcodes.h
@@ -23,17 +23,17 @@ typedef struct {
 } Frame;
 
 #define MEMORY_SIZE 65536
-#define FRAME_STACK_SIZE 32 
-#define RETURN_STACK_SIZE 256
+#define FRAMES_SIZE 32 
+#define STACK_SIZE 256
 typedef struct {
   uint32_t pc; /* Program counter */
   uint32_t fp; /* Frame pointer (last allocated value) */
   uint32_t rp; /* Return stack pointer (top of stack) */
   uint32_t mp; /* Memory pointer (last allocated value) */
-  uint32_t frame_stack_size;
-  Frame frame_stack[FRAME_STACK_SIZE];
-  uint32_t return_stack_size;
-  Value return_stack[RETURN_STACK_SIZE];
+  uint32_t frames_size;
+  Frame frames[FRAMES_SIZE];
+  uint32_t stack_size;
+  Value stack[STACK_SIZE];
   uint32_t memory_size;
   Value memory[MEMORY_SIZE]; /* Memory array */
 } VM;
@@ -46,6 +46,8 @@ typedef enum {
   OP_STOREI,  /* stri : next memory location = src1 as int */
   OP_STOREU,  /* stru : next memory location = src1 as uint */
   OP_STOREF,  /* strf : next memory location = src1 as float */
+  OP_PUSH_ARGS, /* */
+  OP_POP_ARGS,  /* */
   OP_ADD_INT, /* addi : dest = src1 + src2  */
   OP_SUB_INT, /* subs : dest = src1 - src2  */
   OP_MUL_INT, /* mulm : dest = src1 * src2  */
diff --git a/src/vm.c b/src/vm.c
index 96006d4..f523f3a 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -3,19 +3,19 @@
 
 #define COMPARE_AND_JUMP(type, accessor, op)                                   \
   do {                                                                         \
-    type value = vm->frame_stack[vm->fp].registers[src1].accessor;             \
-    type value2 = vm->frame_stack[vm->fp].registers[src2].accessor;            \
-    vm->pc = (value op value2) ? vm->frame_stack[vm->fp].registers[dest].u     \
-                               : vm->pc;                                       \
+    type value = vm->frames[vm->fp].registers[src1].accessor;                  \
+    type value2 = vm->frames[vm->fp].registers[src2].accessor;                 \
+    vm->pc =                                                                   \
+        (value op value2) ? vm->frames[vm->fp].registers[dest].u : vm->pc;     \
     return true;                                                               \
   } while (0)
 
 #define MATH_OP(accessor, op)                                                  \
   do {                                                                         \
-    vm->frame_stack[vm->fp].registers[dest].accessor =                         \
-        vm->frame_stack[vm->fp]                                                \
+    vm->frames[vm->fp].registers[dest].accessor =                              \
+        vm->frames[vm->fp]                                                     \
             .registers[src1]                                                   \
-            .accessor op vm->frame_stack[vm->fp]                               \
+            .accessor op vm->frames[vm->fp]                                    \
             .registers[src2]                                                   \
             .accessor;                                                         \
     return true;                                                               \
@@ -54,45 +54,44 @@ bool step_vm(VM *vm) {
   case OP_HALT:
     return false;
   case OP_CALL:
-    vm->return_stack[++vm->rp].u = vm->pc; /* push return address */
-    vm->pc = vm->frame_stack[vm->fp]
+    vm->stack[++vm->rp].u = vm->pc; /* push return address */
+    vm->pc = vm->frames[vm->fp]
                  .registers[dest]
                  .u; /* set pc to location of function in memory */
     vm->fp++;        /* increment to the next free frame */
-    vm->frame_stack[vm->fp].allocated.start =
+    vm->frames[vm->fp].allocated.start =
         vm->mp; /* set start of new memory block */
     return true;
   case OP_RETURN:
-    vm->pc = vm->return_stack[vm->rp].u;         /* set pc to return address */
-    Slice s = vm->frame_stack[vm->fp].allocated; /* get allocated slice */
+    vm->pc = vm->stack[vm->rp].u;           /* set pc to return address */
+    Slice s = vm->frames[vm->fp].allocated; /* get allocated slice */
     memset(&vm->memory[s.start], 0,
            s.end - s.start); /* deallocate memory from slice */
-    uint32_t parent_rp = vm->frame_stack[vm->fp - 1].rp; /* get parents rp */
-    vm->frame_stack[vm->fp - 1].registers[parent_rp++] =
-        vm->frame_stack[vm->fp]
-            .registers[src1]; /* set the return value to the last register in
-                                 the parent frame */
-    memset(&vm->frame_stack[vm->fp], 0, sizeof(Frame)); /* reset the frame */
-    vm->fp--;                                           /* pop the frame */
+    uint32_t parent_rp = vm->frames[vm->fp - 1].rp; /* get parents rp */
+    vm->frames[vm->fp - 1].registers[parent_rp++] =
+        vm->frames[vm->fp].registers[src1]; /* set the return value to the last
+                                               register in the parent frame */
+    memset(&vm->frames[vm->fp], 0, sizeof(Frame)); /* reset the frame */
+    vm->fp--;                                      /* pop the frame */
     vm->mp = s.start; /* reset memory pointer to start of old slice */
     return true;
   case OP_LOADI:
-    vm->frame_stack[vm->fp].registers[dest].i = vm->memory[vm->pc++].i;
+    vm->frames[vm->fp].registers[dest].i = vm->memory[vm->pc++].i;
     return true;
   case OP_LOADU:
-    vm->frame_stack[vm->fp].registers[dest].u = vm->memory[vm->pc++].u;
+    vm->frames[vm->fp].registers[dest].u = vm->memory[vm->pc++].u;
     return true;
   case OP_LOADF:
-    vm->frame_stack[vm->fp].registers[dest].f = vm->memory[vm->pc++].f;
+    vm->frames[vm->fp].registers[dest].f = vm->memory[vm->pc++].f;
     return true;
   case OP_STOREI:
-    vm->memory[vm->pc++].i = vm->frame_stack[vm->fp].registers[src1].i;
+    vm->memory[vm->pc++].i = vm->frames[vm->fp].registers[src1].i;
     return true;
   case OP_STOREU:
-    vm->memory[vm->pc++].u = vm->frame_stack[vm->fp].registers[src1].u;
+    vm->memory[vm->pc++].u = vm->frames[vm->fp].registers[src1].u;
     return true;
   case OP_STOREF:
-    vm->memory[vm->pc++].f = vm->frame_stack[vm->fp].registers[src1].f;
+    vm->memory[vm->pc++].f = vm->frames[vm->fp].registers[src1].f;
     return true;
   case OP_ADD_INT:
     MATH_OP(i, +);
@@ -119,27 +118,26 @@ bool step_vm(VM *vm) {
   case OP_DIV_REAL:
     MATH_OP(f, /);
   case OP_REAL_TO_INT:
-    vm->frame_stack[vm->fp].registers[dest].i =
-        (int32_t)(vm->frame_stack[vm->fp].registers[src1].f);
+    vm->frames[vm->fp].registers[dest].i =
+        (int32_t)(vm->frames[vm->fp].registers[src1].f);
     return true;
   case OP_INT_TO_REAL:
-    vm->frame_stack[vm->fp].registers[dest].f =
-        (float)(vm->frame_stack[vm->fp].registers[src1].i);
+    vm->frames[vm->fp].registers[dest].f =
+        (float)(vm->frames[vm->fp].registers[src1].i);
     return true;
   case OP_REAL_TO_UINT:
-    vm->frame_stack[vm->fp].registers[dest].u =
-        (uint32_t)(vm->frame_stack[vm->fp].registers[src1].f);
+    vm->frames[vm->fp].registers[dest].u =
+        (uint32_t)(vm->frames[vm->fp].registers[src1].f);
     return true;
   case OP_UINT_TO_REAL:
-    vm->frame_stack[vm->fp].registers[dest].f =
-        (float)(vm->frame_stack[vm->fp].registers[src1].u);
+    vm->frames[vm->fp].registers[dest].f =
+        (float)(vm->frames[vm->fp].registers[src1].u);
     return true;
   case OP_MOV:
-    vm->frame_stack[vm->fp].registers[dest] =
-        vm->frame_stack[vm->fp].registers[src1];
+    vm->frames[vm->fp].registers[dest] = vm->frames[vm->fp].registers[src1];
     return true;
   case OP_JMP:
-    vm->pc = vm->frame_stack[vm->fp].registers[src1].u; /* Jump to address */
+    vm->pc = vm->frames[vm->fp].registers[src1].u; /* Jump to address */
     return true;
   case OP_JEQ_UINT: {
     COMPARE_AND_JUMP(uint32_t, u, ==);
@@ -187,50 +185,48 @@ bool step_vm(VM *vm) {
     COMPARE_AND_JUMP(float, u, <=);
   }
   case OP_INT_TO_STRING: {
-    int32_t a =
-        (int32_t)vm->frame_stack[vm->fp].registers[src1].i; /* get value */
-    uint32_t str_dest = (uint32_t)vm->frame_stack[vm->fp]
+    int32_t a = (int32_t)vm->frames[vm->fp].registers[src1].i; /* get value */
+    uint32_t str_dest = (uint32_t)vm->frames[vm->fp]
                             .allocated.end; /* get start of unallocated */
-    vm->frame_stack[vm->fp].registers[dest].u =
+    vm->frames[vm->fp].registers[dest].u =
         str_dest; /* store ptr of string to dest register */
     char buffer[32];
     int len = sprintf(buffer, "%d", a);
     mem_strcpy(vm->memory, buffer, len, str_dest); /* copy buffer to dest */
-    vm->frame_stack[vm->fp].allocated.end +=
+    vm->frames[vm->fp].allocated.end +=
         ((len / 4) + (len % 4) + 1); /* increment to end of allocated */
     return true;
   }
   case OP_UINT_TO_STRING: {
-    uint32_t a =
-        (uint32_t)vm->frame_stack[vm->fp].registers[src1].u; /* get value */
-    uint32_t str_dest = (uint32_t)vm->frame_stack[vm->fp]
+    uint32_t a = (uint32_t)vm->frames[vm->fp].registers[src1].u; /* get value */
+    uint32_t str_dest = (uint32_t)vm->frames[vm->fp]
                             .allocated.end; /* get start of unallocated */
-    vm->frame_stack[vm->fp].registers[dest].u =
+    vm->frames[vm->fp].registers[dest].u =
         str_dest; /* store ptr of string to dest register */
     char buffer[32];
     int len = sprintf(buffer, "%d", a);
     mem_strcpy(vm->memory, buffer, len, str_dest); /* copy buffer to dest */
-    vm->frame_stack[vm->fp].allocated.end +=
+    vm->frames[vm->fp].allocated.end +=
         ((len / 4) + (len % 4) + 1); /* increment to end of allocated */
     return true;
   }
   case OP_REAL_TO_STRING: {
-    float a = (float)vm->frame_stack[vm->fp].registers[src1].f; /* get value */
-    uint32_t str_dest = (uint32_t)vm->frame_stack[vm->fp]
+    float a = (float)vm->frames[vm->fp].registers[src1].f; /* get value */
+    uint32_t str_dest = (uint32_t)vm->frames[vm->fp]
                             .allocated.end; /* get start of unallocated */
-    vm->frame_stack[vm->fp].registers[dest].u =
+    vm->frames[vm->fp].registers[dest].u =
         str_dest; /* store ptr of string to dest register */
     char buffer[32];
     int len = sprintf(buffer, "%f", a);
     mem_strcpy(vm->memory, buffer, len, str_dest); /* copy buffer to dest */
-    vm->frame_stack[vm->fp].allocated.end +=
+    vm->frames[vm->fp].allocated.end +=
         ((len / 4) + (len % 4) + 1); /* increment to end of allocated */
     return true;
   }
   case OP_READ_STRING: {
-    uint32_t str_dest = (uint32_t)vm->frame_stack[vm->fp]
+    uint32_t str_dest = (uint32_t)vm->frames[vm->fp]
                             .allocated.end; /* get start of unallocated */
-    vm->frame_stack[vm->fp].registers[dest].u =
+    vm->frames[vm->fp].registers[dest].u =
         str_dest; /* store ptr of string to dest register */
     uint32_t buffer = str_dest + 1;
     uint32_t length = 0;
@@ -244,12 +240,12 @@ bool step_vm(VM *vm) {
       length++;
     }
     vm->memory[str_dest].u = length;
-    vm->frame_stack[vm->fp].allocated.end +=
+    vm->frames[vm->fp].allocated.end +=
         length + 1; /* increment to end of allocated */
     return true;
   }
   case OP_PRINT_STRING: {
-    uint32_t ptr = (uint32_t)vm->frame_stack[vm->fp].registers[src1].u;
+    uint32_t ptr = (uint32_t)vm->frames[vm->fp].registers[src1].u;
     uint32_t length = vm->memory[ptr].u;
     uint32_t str_src = ptr + 1;
     uint32_t i;
@@ -263,8 +259,8 @@ bool step_vm(VM *vm) {
     return true;
   }
   case OP_CMP_STRING: {
-    uint32_t addr1 = (uint32_t)vm->frame_stack[vm->fp].registers[src1].u;
-    uint32_t addr2 = (uint32_t)vm->frame_stack[vm->fp].registers[src2].u;
+    uint32_t addr1 = (uint32_t)vm->frames[vm->fp].registers[src1].u;
+    uint32_t addr2 = (uint32_t)vm->frames[vm->fp].registers[src2].u;
     uint32_t length1 = vm->memory[addr1 - 1].u;
     uint32_t length2 = vm->memory[addr2 - 1].u;
     uint32_t equal = 1;