diff --git a/examples/micropython.py b/examples/micropython.py
index 091c92deb3dca6ca902e9117b0e306df006208b2..f91da94f41e6ecce14d4ca4c6363d819aa70aa2b 100644
--- a/examples/micropython.py
+++ b/examples/micropython.py
@@ -5,4 +5,4 @@
 def nodecor(x):
     return x
 
-byte_code = native = viper = nodecor
+bytecode = native = viper = nodecor
diff --git a/py/bc.h b/py/bc.h
index a6d41c160e74d1498ad820a609caacc78ede9821..6c1e45b2b37406f71b6fa6cca0919c039ed49065 100644
--- a/py/bc.h
+++ b/py/bc.h
@@ -36,10 +36,10 @@ typedef struct _mp_exc_stack {
     byte opcode;
 } mp_exc_stack_t;
 
-mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret);
-mp_vm_return_kind_t mp_execute_byte_code_2(const byte *code_info, const byte **ip_in_out, mp_obj_t *fastn, mp_obj_t **sp_in_out, mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out, volatile mp_obj_t inject_exc);
-void mp_byte_code_print(const byte *code, int len);
-void mp_byte_code_print2(const byte *code, int len);
+mp_vm_return_kind_t mp_execute_bytecode(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret);
+mp_vm_return_kind_t mp_execute_bytecode2(const byte *code_info, const byte **ip_in_out, mp_obj_t *fastn, mp_obj_t **sp_in_out, mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out, volatile mp_obj_t inject_exc);
+void mp_bytecode_print(const byte *code, int len);
+void mp_bytecode_print2(const byte *code, int len);
 
 // Helper macros to access pointer with least significant bit holding a flag
 #define MP_TAGPTR_PTR(x) ((void*)((machine_uint_t)(x) & ~((machine_uint_t)1)))
diff --git a/py/compile.c b/py/compile.c
index 8a26f6dc35743e33496ab87f29ed016900a4d883..36ffa928ee5b15e05a806769b1b08f4a1ec62a38 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -1146,7 +1146,7 @@ STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_
     }
 
     qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
-    if (attr == MP_QSTR_byte_code) {
+    if (attr == MP_QSTR_bytecode) {
         *emit_options = MP_EMIT_OPT_BYTE_CODE;
 #if MICROPY_EMIT_NATIVE
     } else if (attr == MP_QSTR_native) {
diff --git a/py/emitbc.c b/py/emitbc.c
index 6a8861eaef7331c6902a6dbae2a742c8d3790756..e9c3b164faf33b31b4af160e2d5c639db592c8bd 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -59,8 +59,8 @@ struct _emit_t {
 
     uint code_info_offset;
     uint code_info_size;
-    uint byte_code_offset;
-    uint byte_code_size;
+    uint bytecode_offset;
+    uint bytecode_size;
     byte *code_base; // stores both byte code and code info
     byte dummy_data[8];
 };
@@ -121,36 +121,36 @@ STATIC void emit_write_code_info_bytes_lines(emit_t* emit, uint bytes_to_skip, u
 #endif
 
 // all functions must go through this one to emit byte code
-STATIC byte* emit_get_cur_to_write_byte_code(emit_t* emit, int num_bytes_to_write) {
+STATIC byte* emit_get_cur_to_write_bytecode(emit_t* emit, int num_bytes_to_write) {
     //printf("emit %d\n", num_bytes_to_write);
     if (emit->pass < MP_PASS_EMIT) {
-        emit->byte_code_offset += num_bytes_to_write;
+        emit->bytecode_offset += num_bytes_to_write;
         return emit->dummy_data;
     } else {
-        assert(emit->byte_code_offset + num_bytes_to_write <= emit->byte_code_size);
-        byte *c = emit->code_base + emit->code_info_size + emit->byte_code_offset;
-        emit->byte_code_offset += num_bytes_to_write;
+        assert(emit->bytecode_offset + num_bytes_to_write <= emit->bytecode_size);
+        byte *c = emit->code_base + emit->code_info_size + emit->bytecode_offset;
+        emit->bytecode_offset += num_bytes_to_write;
         return c;
     }
 }
 
-STATIC void emit_align_byte_code_to_machine_word(emit_t* emit) {
-    emit->byte_code_offset = (emit->byte_code_offset + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1));
+STATIC void emit_align_bytecode_to_machine_word(emit_t* emit) {
+    emit->bytecode_offset = (emit->bytecode_offset + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1));
 }
 
-STATIC void emit_write_byte_code_byte(emit_t* emit, byte b1) {
-    byte* c = emit_get_cur_to_write_byte_code(emit, 1);
+STATIC void emit_write_bytecode_byte(emit_t* emit, byte b1) {
+    byte* c = emit_get_cur_to_write_bytecode(emit, 1);
     c[0] = b1;
 }
 
-STATIC void emit_write_byte_code_byte_byte(emit_t* emit, byte b1, uint b2) {
+STATIC void emit_write_bytecode_byte_byte(emit_t* emit, byte b1, uint b2) {
     assert((b2 & (~0xff)) == 0);
-    byte* c = emit_get_cur_to_write_byte_code(emit, 2);
+    byte* c = emit_get_cur_to_write_bytecode(emit, 2);
     c[0] = b1;
     c[1] = b2;
 }
 
-STATIC void emit_write_byte_code_uint(emit_t* emit, uint num) {
+STATIC void emit_write_bytecode_uint(emit_t* emit, uint num) {
     // We store each 7 bits in a separate byte, and that's how many bytes needed
     byte buf[(BYTES_PER_WORD * 8 + 6) / 7];
     byte *p = buf + sizeof(buf);
@@ -159,16 +159,16 @@ STATIC void emit_write_byte_code_uint(emit_t* emit, uint num) {
         *--p = num & 0x7f;
         num >>= 7;
     } while (num != 0);
-    byte* c = emit_get_cur_to_write_byte_code(emit, buf + sizeof(buf) - p);
+    byte* c = emit_get_cur_to_write_bytecode(emit, buf + sizeof(buf) - p);
     while (p != buf + sizeof(buf) - 1) {
         *c++ = *p++ | 0x80;
     }
     *c = *p;
 }
 
-// Similar to emit_write_byte_code_uint(), just some extra handling to encode sign
-STATIC void emit_write_byte_code_byte_int(emit_t* emit, byte b1, machine_int_t num) {
-    emit_write_byte_code_byte(emit, b1);
+// Similar to emit_write_bytecode_uint(), just some extra handling to encode sign
+STATIC void emit_write_bytecode_byte_int(emit_t* emit, byte b1, machine_int_t num) {
+    emit_write_bytecode_byte(emit, b1);
 
     // We store each 7 bits in a separate byte, and that's how many bytes needed
     byte buf[(BYTES_PER_WORD * 8 + 6) / 7];
@@ -186,64 +186,64 @@ STATIC void emit_write_byte_code_byte_int(emit_t* emit, byte b1, machine_int_t n
         *--p = 0;
     }
 
-    byte* c = emit_get_cur_to_write_byte_code(emit, buf + sizeof(buf) - p);
+    byte* c = emit_get_cur_to_write_bytecode(emit, buf + sizeof(buf) - p);
     while (p != buf + sizeof(buf) - 1) {
         *c++ = *p++ | 0x80;
     }
     *c = *p;
 }
 
-STATIC void emit_write_byte_code_byte_uint(emit_t* emit, byte b, uint num) {
-    emit_write_byte_code_byte(emit, b);
-    emit_write_byte_code_uint(emit, num);
+STATIC void emit_write_bytecode_byte_uint(emit_t* emit, byte b, uint num) {
+    emit_write_bytecode_byte(emit, b);
+    emit_write_bytecode_uint(emit, num);
 }
 
 // aligns the pointer so it is friendly to GC
-STATIC void emit_write_byte_code_byte_ptr(emit_t* emit, byte b, void *ptr) {
-    emit_write_byte_code_byte(emit, b);
-    emit_align_byte_code_to_machine_word(emit);
-    machine_uint_t *c = (machine_uint_t*)emit_get_cur_to_write_byte_code(emit, sizeof(machine_uint_t));
+STATIC void emit_write_bytecode_byte_ptr(emit_t* emit, byte b, void *ptr) {
+    emit_write_bytecode_byte(emit, b);
+    emit_align_bytecode_to_machine_word(emit);
+    machine_uint_t *c = (machine_uint_t*)emit_get_cur_to_write_bytecode(emit, sizeof(machine_uint_t));
     *c = (machine_uint_t)ptr;
 }
 
 /* currently unused
-STATIC void emit_write_byte_code_byte_uint_uint(emit_t* emit, byte b, uint num1, uint num2) {
-    emit_write_byte_code_byte(emit, b);
-    emit_write_byte_code_byte_uint(emit, num1);
-    emit_write_byte_code_byte_uint(emit, num2);
+STATIC void emit_write_bytecode_byte_uint_uint(emit_t* emit, byte b, uint num1, uint num2) {
+    emit_write_bytecode_byte(emit, b);
+    emit_write_bytecode_byte_uint(emit, num1);
+    emit_write_bytecode_byte_uint(emit, num2);
 }
 */
 
-STATIC void emit_write_byte_code_byte_qstr(emit_t* emit, byte b, qstr qstr) {
-    emit_write_byte_code_byte_uint(emit, b, qstr);
+STATIC void emit_write_bytecode_byte_qstr(emit_t* emit, byte b, qstr qstr) {
+    emit_write_bytecode_byte_uint(emit, b, qstr);
 }
 
 // unsigned labels are relative to ip following this instruction, stored as 16 bits
-STATIC void emit_write_byte_code_byte_unsigned_label(emit_t* emit, byte b1, uint label) {
-    uint byte_code_offset;
+STATIC void emit_write_bytecode_byte_unsigned_label(emit_t* emit, byte b1, uint label) {
+    uint bytecode_offset;
     if (emit->pass < MP_PASS_EMIT) {
-        byte_code_offset = 0;
+        bytecode_offset = 0;
     } else {
-        byte_code_offset = emit->label_offsets[label] - emit->byte_code_offset - 3;
+        bytecode_offset = emit->label_offsets[label] - emit->bytecode_offset - 3;
     }
-    byte *c = emit_get_cur_to_write_byte_code(emit, 3);
+    byte *c = emit_get_cur_to_write_bytecode(emit, 3);
     c[0] = b1;
-    c[1] = byte_code_offset;
-    c[2] = byte_code_offset >> 8;
+    c[1] = bytecode_offset;
+    c[2] = bytecode_offset >> 8;
 }
 
 // signed labels are relative to ip following this instruction, stored as 16 bits, in excess
-STATIC void emit_write_byte_code_byte_signed_label(emit_t* emit, byte b1, uint label) {
-    int byte_code_offset;
+STATIC void emit_write_bytecode_byte_signed_label(emit_t* emit, byte b1, uint label) {
+    int bytecode_offset;
     if (emit->pass < MP_PASS_EMIT) {
-        byte_code_offset = 0;
+        bytecode_offset = 0;
     } else {
-        byte_code_offset = emit->label_offsets[label] - emit->byte_code_offset - 3 + 0x8000;
+        bytecode_offset = emit->label_offsets[label] - emit->bytecode_offset - 3 + 0x8000;
     }
-    byte* c = emit_get_cur_to_write_byte_code(emit, 3);
+    byte* c = emit_get_cur_to_write_bytecode(emit, 3);
     c[0] = b1;
-    c[1] = byte_code_offset;
-    c[2] = byte_code_offset >> 8;
+    c[1] = bytecode_offset;
+    c[2] = bytecode_offset >> 8;
 }
 
 STATIC void emit_bc_set_native_types(emit_t *emit, bool do_native_types) {
@@ -259,7 +259,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
     if (pass < MP_PASS_EMIT) {
         memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(uint));
     }
-    emit->byte_code_offset = 0;
+    emit->bytecode_offset = 0;
     emit->code_info_offset = 0;
 
     // write code info size; use maximum space (4 bytes) to write it; TODO possible optimise this
@@ -278,7 +278,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
 
     // bytecode prelude: local state size and exception stack size; 16 bit uints for now
     {
-        byte* c = emit_get_cur_to_write_byte_code(emit, 4);
+        byte* c = emit_get_cur_to_write_bytecode(emit, 4);
         uint n_state = scope->num_locals + scope->stack_size;
         if (n_state == 0) {
             // Need at least 1 entry in the state, in the case an exception is
@@ -301,11 +301,11 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
         }
     }
     assert(num_cell <= 255);
-    emit_write_byte_code_byte(emit, num_cell); // write number of locals that are cells
+    emit_write_bytecode_byte(emit, num_cell); // write number of locals that are cells
     for (int i = 0; i < scope->id_info_len; i++) {
         id_info_t *id = &scope->id_info[i];
         if (id->kind == ID_INFO_KIND_CELL) {
-            emit_write_byte_code_byte(emit, id->local_num); // write the local which should be converted to a cell
+            emit_write_bytecode_byte(emit, id->local_num); // write the local which should be converted to a cell
         }
     }
 }
@@ -317,21 +317,21 @@ STATIC void emit_bc_end_pass(emit_t *emit) {
     }
 
     *emit_get_cur_to_write_code_info(emit, 1) = 0; // end of line number info
-    emit_align_code_info_to_machine_word(emit); // align so that following byte_code is aligned
+    emit_align_code_info_to_machine_word(emit); // align so that following bytecode is aligned
 
     if (emit->pass == MP_PASS_CODE_SIZE) {
         // calculate size of code in bytes
         emit->code_info_size = emit->code_info_offset;
-        emit->byte_code_size = emit->byte_code_offset;
-        emit->code_base = m_new0(byte, emit->code_info_size + emit->byte_code_size);
+        emit->bytecode_size = emit->bytecode_offset;
+        emit->code_base = m_new0(byte, emit->code_info_size + emit->bytecode_size);
 
     } else if (emit->pass == MP_PASS_EMIT) {
         qstr *arg_names = m_new(qstr, emit->scope->num_pos_args + emit->scope->num_kwonly_args);
         for (int i = 0; i < emit->scope->num_pos_args + emit->scope->num_kwonly_args; i++) {
             arg_names[i] = emit->scope->id_info[i].qstr;
         }
-        mp_emit_glue_assign_byte_code(emit->scope->raw_code, emit->code_base,
-            emit->code_info_size + emit->byte_code_size,
+        mp_emit_glue_assign_bytecode(emit->scope->raw_code, emit->code_base,
+            emit->code_info_size + emit->bytecode_size,
             emit->scope->num_pos_args, emit->scope->num_kwonly_args, arg_names,
             emit->scope->scope_flags);
     }
@@ -346,14 +346,14 @@ STATIC void emit_bc_adjust_stack_size(emit_t *emit, int delta) {
 }
 
 STATIC void emit_bc_set_source_line(emit_t *emit, int source_line) {
-    //printf("source: line %d -> %d  offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->byte_code_offset);
+    //printf("source: line %d -> %d  offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->bytecode_offset);
 #if MICROPY_ENABLE_SOURCE_LINE
     if (source_line > emit->last_source_line) {
-        uint bytes_to_skip = emit->byte_code_offset - emit->last_source_line_offset;
+        uint bytes_to_skip = emit->bytecode_offset - emit->last_source_line_offset;
         uint lines_to_skip = source_line - emit->last_source_line;
         emit_write_code_info_bytes_lines(emit, bytes_to_skip, lines_to_skip);
         //printf("  %d %d\n", bytes_to_skip, lines_to_skip);
-        emit->last_source_line_offset = emit->byte_code_offset;
+        emit->last_source_line_offset = emit->bytecode_offset;
         emit->last_source_line = source_line;
     }
 #endif
@@ -386,167 +386,167 @@ STATIC void emit_bc_label_assign(emit_t *emit, uint l) {
     if (emit->pass < MP_PASS_EMIT) {
         // assign label offset
         assert(emit->label_offsets[l] == -1);
-        emit->label_offsets[l] = emit->byte_code_offset;
+        emit->label_offsets[l] = emit->bytecode_offset;
     } else {
         // ensure label offset has not changed from MP_PASS_CODE_SIZE to MP_PASS_EMIT
-        //printf("l%d: (at %d vs %d)\n", l, emit->byte_code_offset, emit->label_offsets[l]);
-        assert(emit->label_offsets[l] == emit->byte_code_offset);
+        //printf("l%d: (at %d vs %d)\n", l, emit->bytecode_offset, emit->label_offsets[l]);
+        assert(emit->label_offsets[l] == emit->bytecode_offset);
     }
 }
 
 STATIC void emit_bc_import_name(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr);
 }
 
 STATIC void emit_bc_import_from(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr);
 }
 
 STATIC void emit_bc_import_star(emit_t *emit) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte(emit, MP_BC_IMPORT_STAR);
+    emit_write_bytecode_byte(emit, MP_BC_IMPORT_STAR);
 }
 
 STATIC void emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
     emit_bc_pre(emit, 1);
     switch (tok) {
-        case MP_TOKEN_KW_FALSE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_FALSE); break;
-        case MP_TOKEN_KW_NONE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_NONE); break;
-        case MP_TOKEN_KW_TRUE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_TRUE); break;
-        case MP_TOKEN_ELLIPSIS: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_ELLIPSIS); break;
+        case MP_TOKEN_KW_FALSE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_FALSE); break;
+        case MP_TOKEN_KW_NONE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_NONE); break;
+        case MP_TOKEN_KW_TRUE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_TRUE); break;
+        case MP_TOKEN_ELLIPSIS: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_ELLIPSIS); break;
         default: assert(0);
     }
 }
 
 STATIC void emit_bc_load_const_small_int(emit_t *emit, machine_int_t arg) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg);
+    emit_write_bytecode_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg);
 }
 
 STATIC void emit_bc_load_const_int(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr);
 }
 
 STATIC void emit_bc_load_const_dec(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr);
 }
 
 STATIC void emit_bc_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
     emit_bc_pre(emit, 1);
     if (bytes) {
-        emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr);
+        emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr);
     } else {
-        emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr);
+        emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr);
     }
 }
 
 STATIC void emit_bc_load_null(emit_t *emit) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte(emit, MP_BC_LOAD_NULL);
+    emit_write_bytecode_byte(emit, MP_BC_LOAD_NULL);
 };
 
 STATIC void emit_bc_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) {
     assert(local_num >= 0);
     emit_bc_pre(emit, 1);
     switch (local_num) {
-        case 0: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_0); break;
-        case 1: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_1); break;
-        case 2: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_2); break;
-        default: emit_write_byte_code_byte_uint(emit, MP_BC_LOAD_FAST_N, local_num); break;
+        case 0: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_0); break;
+        case 1: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_1); break;
+        case 2: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_2); break;
+        default: emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_FAST_N, local_num); break;
     }
 }
 
 STATIC void emit_bc_load_deref(emit_t *emit, qstr qstr, int local_num) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_uint(emit, MP_BC_LOAD_DEREF, local_num);
+    emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_DEREF, local_num);
 }
 
 STATIC void emit_bc_load_name(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_NAME, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_NAME, qstr);
 }
 
 STATIC void emit_bc_load_global(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr);
 }
 
 STATIC void emit_bc_load_attr(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr);
 }
 
 STATIC void emit_bc_load_method(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr);
 }
 
 STATIC void emit_bc_load_build_class(emit_t *emit) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte(emit, MP_BC_LOAD_BUILD_CLASS);
+    emit_write_bytecode_byte(emit, MP_BC_LOAD_BUILD_CLASS);
 }
 
 STATIC void emit_bc_load_subscr(emit_t *emit) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte(emit, MP_BC_LOAD_SUBSCR);
+    emit_write_bytecode_byte(emit, MP_BC_LOAD_SUBSCR);
 }
 
 STATIC void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) {
     assert(local_num >= 0);
     emit_bc_pre(emit, -1);
     switch (local_num) {
-        case 0: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_0); break;
-        case 1: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_1); break;
-        case 2: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_2); break;
-        default: emit_write_byte_code_byte_uint(emit, MP_BC_STORE_FAST_N, local_num); break;
+        case 0: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_0); break;
+        case 1: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_1); break;
+        case 2: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_2); break;
+        default: emit_write_bytecode_byte_uint(emit, MP_BC_STORE_FAST_N, local_num); break;
     }
 }
 
 STATIC void emit_bc_store_deref(emit_t *emit, qstr qstr, int local_num) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_uint(emit, MP_BC_STORE_DEREF, local_num);
+    emit_write_bytecode_byte_uint(emit, MP_BC_STORE_DEREF, local_num);
 }
 
 STATIC void emit_bc_store_name(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_NAME, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_NAME, qstr);
 }
 
 STATIC void emit_bc_store_global(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr);
 }
 
 STATIC void emit_bc_store_attr(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, -2);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_ATTR, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_ATTR, qstr);
 }
 
 STATIC void emit_bc_store_subscr(emit_t *emit) {
     emit_bc_pre(emit, -3);
-    emit_write_byte_code_byte(emit, MP_BC_STORE_SUBSCR);
+    emit_write_bytecode_byte(emit, MP_BC_STORE_SUBSCR);
 }
 
 STATIC void emit_bc_delete_fast(emit_t *emit, qstr qstr, int local_num) {
-    emit_write_byte_code_byte_uint(emit, MP_BC_DELETE_FAST, local_num);
+    emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_FAST, local_num);
 }
 
 STATIC void emit_bc_delete_deref(emit_t *emit, qstr qstr, int local_num) {
-    emit_write_byte_code_byte_uint(emit, MP_BC_DELETE_DEREF, local_num);
+    emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_DEREF, local_num);
 }
 
 STATIC void emit_bc_delete_name(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_DELETE_NAME, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_NAME, qstr);
 }
 
 STATIC void emit_bc_delete_global(emit_t *emit, qstr qstr) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr);
+    emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr);
 }
 
 STATIC void emit_bc_delete_attr(emit_t *emit, qstr qstr) {
@@ -563,52 +563,52 @@ STATIC void emit_bc_delete_subscr(emit_t *emit) {
 
 STATIC void emit_bc_dup_top(emit_t *emit) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte(emit, MP_BC_DUP_TOP);
+    emit_write_bytecode_byte(emit, MP_BC_DUP_TOP);
 }
 
 STATIC void emit_bc_dup_top_two(emit_t *emit) {
     emit_bc_pre(emit, 2);
-    emit_write_byte_code_byte(emit, MP_BC_DUP_TOP_TWO);
+    emit_write_bytecode_byte(emit, MP_BC_DUP_TOP_TWO);
 }
 
 STATIC void emit_bc_pop_top(emit_t *emit) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte(emit, MP_BC_POP_TOP);
+    emit_write_bytecode_byte(emit, MP_BC_POP_TOP);
 }
 
 STATIC void emit_bc_rot_two(emit_t *emit) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte(emit, MP_BC_ROT_TWO);
+    emit_write_bytecode_byte(emit, MP_BC_ROT_TWO);
 }
 
 STATIC void emit_bc_rot_three(emit_t *emit) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte(emit, MP_BC_ROT_THREE);
+    emit_write_bytecode_byte(emit, MP_BC_ROT_THREE);
 }
 
 STATIC void emit_bc_jump(emit_t *emit, uint label) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP, label);
+    emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP, label);
 }
 
 STATIC void emit_bc_pop_jump_if_true(emit_t *emit, uint label) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label);
+    emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label);
 }
 
 STATIC void emit_bc_pop_jump_if_false(emit_t *emit, uint label) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label);
+    emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label);
 }
 
 STATIC void emit_bc_jump_if_true_or_pop(emit_t *emit, uint label) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label);
+    emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label);
 }
 
 STATIC void emit_bc_jump_if_false_or_pop(emit_t *emit, uint label) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label);
+    emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label);
 }
 
 STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) {
@@ -616,44 +616,44 @@ STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) {
         emit_bc_jump(emit, label);
     } else {
         emit_bc_pre(emit, 0);
-        emit_write_byte_code_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label);
-        emit_write_byte_code_byte(emit, except_depth);
+        emit_write_bytecode_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label);
+        emit_write_bytecode_byte(emit, except_depth);
     }
 }
 
 STATIC void emit_bc_setup_with(emit_t *emit, uint label) {
     emit_bc_pre(emit, 7);
-    emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label);
+    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label);
 }
 
 STATIC void emit_bc_with_cleanup(emit_t *emit) {
     emit_bc_pre(emit, -7);
-    emit_write_byte_code_byte(emit, MP_BC_WITH_CLEANUP);
+    emit_write_bytecode_byte(emit, MP_BC_WITH_CLEANUP);
 }
 
 STATIC void emit_bc_setup_except(emit_t *emit, uint label) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label);
+    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label);
 }
 
 STATIC void emit_bc_setup_finally(emit_t *emit, uint label) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label);
+    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label);
 }
 
 STATIC void emit_bc_end_finally(emit_t *emit) {
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte(emit, MP_BC_END_FINALLY);
+    emit_write_bytecode_byte(emit, MP_BC_END_FINALLY);
 }
 
 STATIC void emit_bc_get_iter(emit_t *emit) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte(emit, MP_BC_GET_ITER);
+    emit_write_bytecode_byte(emit, MP_BC_GET_ITER);
 }
 
 STATIC void emit_bc_for_iter(emit_t *emit, uint label) {
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_unsigned_label(emit, MP_BC_FOR_ITER, label);
+    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_FOR_ITER, label);
 }
 
 STATIC void emit_bc_for_iter_end(emit_t *emit) {
@@ -662,23 +662,23 @@ STATIC void emit_bc_for_iter_end(emit_t *emit) {
 
 STATIC void emit_bc_pop_block(emit_t *emit) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte(emit, MP_BC_POP_BLOCK);
+    emit_write_bytecode_byte(emit, MP_BC_POP_BLOCK);
 }
 
 STATIC void emit_bc_pop_except(emit_t *emit) {
     emit_bc_pre(emit, 0);
-    emit_write_byte_code_byte(emit, MP_BC_POP_EXCEPT);
+    emit_write_bytecode_byte(emit, MP_BC_POP_EXCEPT);
 }
 
 STATIC void emit_bc_unary_op(emit_t *emit, mp_unary_op_t op) {
     if (op == MP_UNARY_OP_NOT) {
         emit_bc_pre(emit, 0);
-        emit_write_byte_code_byte_byte(emit, MP_BC_UNARY_OP, MP_UNARY_OP_BOOL);
+        emit_write_bytecode_byte_byte(emit, MP_BC_UNARY_OP, MP_UNARY_OP_BOOL);
         emit_bc_pre(emit, 0);
-        emit_write_byte_code_byte(emit, MP_BC_NOT);
+        emit_write_bytecode_byte(emit, MP_BC_NOT);
     } else {
         emit_bc_pre(emit, 0);
-        emit_write_byte_code_byte_byte(emit, MP_BC_UNARY_OP, op);
+        emit_write_bytecode_byte_byte(emit, MP_BC_UNARY_OP, op);
     }
 }
 
@@ -692,98 +692,98 @@ STATIC void emit_bc_binary_op(emit_t *emit, mp_binary_op_t op) {
         op = MP_BINARY_OP_IS;
     }
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_byte(emit, MP_BC_BINARY_OP, op);
+    emit_write_bytecode_byte_byte(emit, MP_BC_BINARY_OP, op);
     if (invert) {
         emit_bc_pre(emit, 0);
-        emit_write_byte_code_byte(emit, MP_BC_NOT);
+        emit_write_bytecode_byte(emit, MP_BC_NOT);
     }
 }
 
 STATIC void emit_bc_build_tuple(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_bc_pre(emit, 1 - n_args);
-    emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_TUPLE, n_args);
+    emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_TUPLE, n_args);
 }
 
 STATIC void emit_bc_build_list(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_bc_pre(emit, 1 - n_args);
-    emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_LIST, n_args);
+    emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_LIST, n_args);
 }
 
 STATIC void emit_bc_list_append(emit_t *emit, int list_stack_index) {
     assert(list_stack_index >= 0);
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_uint(emit, MP_BC_LIST_APPEND, list_stack_index);
+    emit_write_bytecode_byte_uint(emit, MP_BC_LIST_APPEND, list_stack_index);
 }
 
 STATIC void emit_bc_build_map(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_bc_pre(emit, 1);
-    emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_MAP, n_args);
+    emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_MAP, n_args);
 }
 
 STATIC void emit_bc_store_map(emit_t *emit) {
     emit_bc_pre(emit, -2);
-    emit_write_byte_code_byte(emit, MP_BC_STORE_MAP);
+    emit_write_bytecode_byte(emit, MP_BC_STORE_MAP);
 }
 
 STATIC void emit_bc_map_add(emit_t *emit, int map_stack_index) {
     assert(map_stack_index >= 0);
     emit_bc_pre(emit, -2);
-    emit_write_byte_code_byte_uint(emit, MP_BC_MAP_ADD, map_stack_index);
+    emit_write_bytecode_byte_uint(emit, MP_BC_MAP_ADD, map_stack_index);
 }
 
 STATIC void emit_bc_build_set(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_bc_pre(emit, 1 - n_args);
-    emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_SET, n_args);
+    emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_SET, n_args);
 }
 
 STATIC void emit_bc_set_add(emit_t *emit, int set_stack_index) {
     assert(set_stack_index >= 0);
     emit_bc_pre(emit, -1);
-    emit_write_byte_code_byte_uint(emit, MP_BC_SET_ADD, set_stack_index);
+    emit_write_bytecode_byte_uint(emit, MP_BC_SET_ADD, set_stack_index);
 }
 
 STATIC void emit_bc_build_slice(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_bc_pre(emit, 1 - n_args);
-    emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_SLICE, n_args);
+    emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_SLICE, n_args);
 }
 
 STATIC void emit_bc_unpack_sequence(emit_t *emit, int n_args) {
     assert(n_args >= 0);
     emit_bc_pre(emit, -1 + n_args);
-    emit_write_byte_code_byte_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args);
+    emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args);
 }
 
 STATIC void emit_bc_unpack_ex(emit_t *emit, int n_left, int n_right) {
     assert(n_left >=0 && n_right >= 0);
     emit_bc_pre(emit, -1 + n_left + n_right + 1);
-    emit_write_byte_code_byte_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8));
+    emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8));
 }
 
 STATIC void emit_bc_make_function(emit_t *emit, scope_t *scope, uint n_pos_defaults, uint n_kw_defaults) {
     if (n_pos_defaults == 0 && n_kw_defaults == 0) {
         emit_bc_pre(emit, 1);
-        emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_FUNCTION, scope->raw_code);
+        emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_FUNCTION, scope->raw_code);
     } else {
         emit_bc_pre(emit, -1);
-        emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_FUNCTION_DEFARGS, scope->raw_code);
+        emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_FUNCTION_DEFARGS, scope->raw_code);
     }
 }
 
 STATIC void emit_bc_make_closure(emit_t *emit, scope_t *scope, uint n_closed_over, uint n_pos_defaults, uint n_kw_defaults) {
     if (n_pos_defaults == 0 && n_kw_defaults == 0) {
         emit_bc_pre(emit, -n_closed_over + 1);
-        emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_CLOSURE, scope->raw_code);
-        emit_write_byte_code_byte(emit, n_closed_over);
+        emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_CLOSURE, scope->raw_code);
+        emit_write_bytecode_byte(emit, n_closed_over);
     } else {
         assert(n_closed_over <= 255);
         emit_bc_pre(emit, -2 - n_closed_over + 1);
-        emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_CLOSURE_DEFARGS, scope->raw_code);
-        emit_write_byte_code_byte(emit, n_closed_over);
+        emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_CLOSURE_DEFARGS, scope->raw_code);
+        emit_write_bytecode_byte(emit, n_closed_over);
     }
 }
 
@@ -798,10 +798,10 @@ STATIC void emit_bc_call_function_method_helper(emit_t *emit, int stack_adj, uin
             emit_bc_load_null(emit);
         }
         emit_bc_pre(emit, stack_adj - n_positional - 2 * n_keyword - 2);
-        emit_write_byte_code_byte_uint(emit, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
+        emit_write_bytecode_byte_uint(emit, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
     } else {
         emit_bc_pre(emit, stack_adj - n_positional - 2 * n_keyword);
-        emit_write_byte_code_byte_uint(emit, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
+        emit_write_bytecode_byte_uint(emit, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
     }
 }
 
@@ -816,25 +816,25 @@ STATIC void emit_bc_call_method(emit_t *emit, int n_positional, int n_keyword, u
 STATIC void emit_bc_return_value(emit_t *emit) {
     emit_bc_pre(emit, -1);
     emit->last_emit_was_return_value = true;
-    emit_write_byte_code_byte(emit, MP_BC_RETURN_VALUE);
+    emit_write_bytecode_byte(emit, MP_BC_RETURN_VALUE);
 }
 
 STATIC void emit_bc_raise_varargs(emit_t *emit, int n_args) {
     assert(0 <= n_args && n_args <= 2);
     emit_bc_pre(emit, -n_args);
-    emit_write_byte_code_byte_byte(emit, MP_BC_RAISE_VARARGS, n_args);
+    emit_write_bytecode_byte_byte(emit, MP_BC_RAISE_VARARGS, n_args);
 }
 
 STATIC void emit_bc_yield_value(emit_t *emit) {
     emit_bc_pre(emit, 0);
     emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
-    emit_write_byte_code_byte(emit, MP_BC_YIELD_VALUE);
+    emit_write_bytecode_byte(emit, MP_BC_YIELD_VALUE);
 }
 
 STATIC void emit_bc_yield_from(emit_t *emit) {
     emit_bc_pre(emit, -1);
     emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
-    emit_write_byte_code_byte(emit, MP_BC_YIELD_FROM);
+    emit_write_bytecode_byte(emit, MP_BC_YIELD_FROM);
 }
 
 const emit_method_table_t emit_bc_method_table = {
diff --git a/py/emitcpy.c b/py/emitcpy.c
index 77967a2a95750c7955cf0800d6cdb2ee5e76d756..a8a6265b8cfe316a1f1b971b475bcd32fc159f57 100644
--- a/py/emitcpy.c
+++ b/py/emitcpy.c
@@ -46,7 +46,7 @@
 
 struct _emit_t {
     int pass;
-    int byte_code_offset;
+    int bytecode_offset;
     int stack_size;
     bool last_emit_was_return_value;
 
@@ -68,7 +68,7 @@ STATIC void emit_cpy_set_native_types(emit_t *emit, bool do_native_types) {
 
 STATIC void emit_cpy_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
     emit->pass = pass;
-    emit->byte_code_offset = 0;
+    emit->bytecode_offset = 0;
     emit->stack_size = 0;
     emit->last_emit_was_return_value = false;
     emit->scope = scope;
@@ -108,20 +108,20 @@ STATIC void emit_cpy_delete_id(emit_t *emit, qstr qstr) {
 }
 
 // TODO: module-polymorphic function (read: name clash if made global)
-static void emit_pre(emit_t *emit, int stack_size_delta, int byte_code_size) {
+static void emit_pre(emit_t *emit, int stack_size_delta, int bytecode_size) {
     emit->stack_size += stack_size_delta;
     if (emit->stack_size > emit->scope->stack_size) {
         emit->scope->stack_size = emit->stack_size;
     }
     emit->last_emit_was_return_value = false;
-    if (emit->pass == MP_PASS_EMIT && byte_code_size > 0) {
-        if (emit->byte_code_offset >= 1000) {
-            printf("%d ", emit->byte_code_offset);
+    if (emit->pass == MP_PASS_EMIT && bytecode_size > 0) {
+        if (emit->bytecode_offset >= 1000) {
+            printf("%d ", emit->bytecode_offset);
         } else {
-            printf("% 4d ", emit->byte_code_offset);
+            printf("% 4d ", emit->bytecode_offset);
         }
     }
-    emit->byte_code_offset += byte_code_size;
+    emit->bytecode_offset += bytecode_size;
 }
 
 STATIC void emit_cpy_label_assign(emit_t *emit, uint l) {
@@ -130,11 +130,11 @@ STATIC void emit_cpy_label_assign(emit_t *emit, uint l) {
     if (emit->pass < MP_PASS_EMIT) {
         // assign label offset
         assert(emit->label_offsets[l] == -1);
-        emit->label_offsets[l] = emit->byte_code_offset;
+        emit->label_offsets[l] = emit->bytecode_offset;
     } else {
         // ensure label offset has not changed from MP_PASS_CODE_SIZE to MP_PASS_EMIT
-        assert(emit->label_offsets[l] == emit->byte_code_offset);
-        //printf("l%d: (at %d)\n", l, emit->byte_code_offset);
+        assert(emit->label_offsets[l] == emit->bytecode_offset);
+        //printf("l%d: (at %d)\n", l, emit->bytecode_offset);
     }
 }
 
@@ -421,7 +421,7 @@ STATIC void emit_cpy_jump(emit_t *emit, uint label) {
     emit_pre(emit, 0, 3);
     if (emit->pass == MP_PASS_EMIT) {
         int dest = emit->label_offsets[label];
-        if (dest < emit->byte_code_offset) {
+        if (dest < emit->bytecode_offset) {
             printf("JUMP_ABSOLUTE %d\n", emit->label_offsets[label]);
         } else {
             printf("JUMP_FORWARD %d\n", emit->label_offsets[label]);
diff --git a/py/emitglue.c b/py/emitglue.c
index ed3b385d9f1b9058d6659b36cf6e8445490c255d..4bd9027317cc8e2b81b546060d4c4a5dca1e9665 100644
--- a/py/emitglue.c
+++ b/py/emitglue.c
@@ -73,7 +73,7 @@ mp_raw_code_t *mp_emit_glue_new_raw_code(void) {
     return rc;
 }
 
-void mp_emit_glue_assign_byte_code(mp_raw_code_t *rc, byte *code, uint len, uint n_pos_args, uint n_kwonly_args, qstr *arg_names, uint scope_flags) {
+void mp_emit_glue_assign_bytecode(mp_raw_code_t *rc, byte *code, uint len, uint n_pos_args, uint n_kwonly_args, qstr *arg_names, uint scope_flags) {
     rc->kind = MP_CODE_BYTE;
     rc->scope_flags = scope_flags;
     rc->n_pos_args = n_pos_args;
@@ -99,7 +99,7 @@ void mp_emit_glue_assign_byte_code(mp_raw_code_t *rc, byte *code, uint len, uint
 #endif
 #if MICROPY_DEBUG_PRINTERS
     if (mp_verbose_flag > 0) {
-        mp_byte_code_print(code, len);
+        mp_bytecode_print(code, len);
     }
 #endif
 }
diff --git a/py/emitglue.h b/py/emitglue.h
index 9d7d2993b291cd5ad5ecf0ffe5d63c48b220444b..bf1a440516bc64b362f65fba651a2540bdf070a9 100644
--- a/py/emitglue.h
+++ b/py/emitglue.h
@@ -59,7 +59,7 @@ void mp_emit_glue_deinit(void);
 
 mp_raw_code_t *mp_emit_glue_new_raw_code(void);
 
-void mp_emit_glue_assign_byte_code(mp_raw_code_t *rc, byte *code, uint len, uint n_pos_args, uint n_kwonly_args, qstr *arg_names, uint scope_flags);
+void mp_emit_glue_assign_bytecode(mp_raw_code_t *rc, byte *code, uint len, uint n_pos_args, uint n_kwonly_args, qstr *arg_names, uint scope_flags);
 void mp_emit_glue_assign_native_code(mp_raw_code_t *rc, void *f, uint len, int n_args);
 void mp_emit_glue_assign_inline_asm_code(mp_raw_code_t *rc, void *f, uint len, int n_args);
 
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 119859a3a4f679585c6717cb27e309adf02adb3e..f8404142a1054829386cd2d61e4d7f03f5390a85 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -100,7 +100,7 @@
 
 // Whether to build functions that print debugging info:
 //   mp_token_show
-//   mp_byte_code_print
+//   mp_bytecode_print
 //   mp_parse_node_print
 #ifndef MICROPY_DEBUG_PRINTERS
 #define MICROPY_DEBUG_PRINTERS (0)
diff --git a/py/objfun.c b/py/objfun.c
index b4cd796c7c26e7d14a841d9d566230d851393cff..f5fbf95806d6f4cee1bb9873086e75a64d70d1c1 100644
--- a/py/objfun.c
+++ b/py/objfun.c
@@ -378,7 +378,7 @@ continue2:;
     DEBUG_printf("Calling: args=%p, n_args=%d, extra_args=%p, n_extra_args=%d\n", args, n_args, extra_args, n_extra_args);
     dump_args(args, n_args);
     dump_args(extra_args, n_extra_args);
-    mp_vm_return_kind_t vm_return_kind = mp_execute_byte_code(self->bytecode, args, n_args, extra_args, n_extra_args, &result);
+    mp_vm_return_kind_t vm_return_kind = mp_execute_bytecode(self->bytecode, args, n_args, extra_args, n_extra_args, &result);
     mp_globals_set(old_globals);
 
     if (vm_return_kind == MP_VM_RETURN_NORMAL) {
diff --git a/py/objgenerator.c b/py/objgenerator.c
index 9c19149164e91fe022e881abc34ded0226bf5bfc..fb8366bae5bf41ca276d0576c3aa7baf3f4053e1 100644
--- a/py/objgenerator.c
+++ b/py/objgenerator.c
@@ -118,7 +118,7 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_
     }
     mp_obj_dict_t *old_globals = mp_globals_get();
     mp_globals_set(self->globals);
-    mp_vm_return_kind_t ret_kind = mp_execute_byte_code_2(self->code_info, &self->ip,
+    mp_vm_return_kind_t ret_kind = mp_execute_bytecode2(self->code_info, &self->ip,
         &self->state[self->n_state - 1], &self->sp, (mp_exc_stack_t*)(self->state + self->n_state),
         &self->exc_sp, throw_value);
     mp_globals_set(old_globals);
@@ -276,7 +276,7 @@ mp_obj_t mp_obj_new_gen_instance(mp_obj_dict_t *globals, const byte *bytecode, u
     o->exc_sp = (mp_exc_stack_t*)(o->state + n_state) - 1;
     o->n_state = n_state;
 
-    // copy args to end of state array, in reverse (that's how mp_execute_byte_code_2 needs it)
+    // copy args to end of state array, in reverse (that's how mp_execute_bytecode2 needs it)
     for (uint i = 0; i < n_args; i++) {
         o->state[n_state - 1 - i] = args[i];
     }
diff --git a/py/qstrdefs.h b/py/qstrdefs.h
index 30fad4413d9965bdffb06aa15e837c08aee0c8b3..8716901c24a4f9a72a1fd6119bf08485f394af15 100644
--- a/py/qstrdefs.h
+++ b/py/qstrdefs.h
@@ -61,7 +61,7 @@ Q(__del__)
 Q(__call__)
 
 Q(micropython)
-Q(byte_code)
+Q(bytecode)
 Q(native)
 Q(viper)
 Q(const)
diff --git a/py/showbc.c b/py/showbc.c
index d8ab4be07447911150b64ce8482fadf4797ceb37..48d5328c20ea4efa613cda259e97809ace4fc8ed 100644
--- a/py/showbc.c
+++ b/py/showbc.c
@@ -54,9 +54,9 @@
     ip += sizeof(machine_uint_t); \
 } while (0)
 
-void mp_byte_code_print2(const byte *ip, int len);
+void mp_bytecode_print2(const byte *ip, int len);
 
-void mp_byte_code_print(const byte *ip, int len) {
+void mp_bytecode_print(const byte *ip, int len) {
     const byte *ip_start = ip;
 
     // get code info size
@@ -99,10 +99,10 @@ void mp_byte_code_print(const byte *ip, int len) {
             printf("  bc=" INT_FMT " line=" UINT_FMT "\n", bc, source_line);
         }
     }
-    mp_byte_code_print2(ip, len - 0);
+    mp_bytecode_print2(ip, len - 0);
 }
 
-void mp_byte_code_print2(const byte *ip, int len) {
+void mp_bytecode_print2(const byte *ip, int len) {
     const byte *ip_start = ip;
     machine_uint_t unum;
     qstr qstr;
diff --git a/py/vm.c b/py/vm.c
index 5b4d0d160d0f498169651c97d7f42b5f6117afc3..36e8db2032f23f510dc6dc83ec21b47da1b9a0e8 100644
--- a/py/vm.c
+++ b/py/vm.c
@@ -47,7 +47,7 @@
 
 #define DETECT_VM_STACK_OVERFLOW (0)
 #if 0
-#define TRACE(ip) mp_byte_code_print2(ip, 1);
+#define TRACE(ip) mp_bytecode_print2(ip, 1);
 #else
 #define TRACE(ip)
 #endif
@@ -104,7 +104,7 @@ typedef enum {
     currently_in_except_block = MP_TAGPTR_TAG(exc_sp->val_sp); /* restore previous state */ \
     exc_sp--; /* pop back to previous exception handler */
 
-mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret) {
+mp_vm_return_kind_t mp_execute_bytecode(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret) {
     const byte *ip = code;
 
     // get code info size, and skip line number table
@@ -155,7 +155,7 @@ mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args,
     }
 
     // execute the byte code
-    mp_vm_return_kind_t vm_return_kind = mp_execute_byte_code_2(code, &ip, &state[n_state - 1], &sp, exc_stack, &exc_sp, MP_OBJ_NULL);
+    mp_vm_return_kind_t vm_return_kind = mp_execute_bytecode2(code, &ip, &state[n_state - 1], &sp, exc_stack, &exc_sp, MP_OBJ_NULL);
 
 #if DETECT_VM_STACK_OVERFLOW
     // We can't check the case when an exception is returned in state[n_state - 1]
@@ -217,10 +217,10 @@ mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args,
 //  MP_VM_RETURN_NORMAL, sp valid, return value in *sp
 //  MP_VM_RETURN_YIELD, ip, sp valid, yielded value in *sp
 //  MP_VM_RETURN_EXCEPTION, exception in fastn[0]
-mp_vm_return_kind_t mp_execute_byte_code_2(const byte *code_info, const byte **ip_in_out,
-                                           mp_obj_t *fastn, mp_obj_t **sp_in_out,
-                                           mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out,
-                                           volatile mp_obj_t inject_exc) {
+mp_vm_return_kind_t mp_execute_bytecode2(const byte *code_info, const byte **ip_in_out,
+                                         mp_obj_t *fastn, mp_obj_t **sp_in_out,
+                                         mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out,
+                                         volatile mp_obj_t inject_exc) {
 #if MICROPY_USE_COMPUTED_GOTO
     #include "vmentrytable.h"
     #define DISPATCH() do { \