diff --git a/py/builtin.c b/py/builtin.c
index d606db1..57d3aa7 100644
--- a/py/builtin.c
+++ b/py/builtin.c
@@ -192,7 +192,7 @@
         mp_obj_t args[2];
         args[0] = MP_OBJ_NEW_SMALL_INT(i1 / i2);
         args[1] = MP_OBJ_NEW_SMALL_INT(i1 % i2);
-        return mp_build_tuple(2, args);
+        return mp_obj_new_tuple(2, args);
     } else {
         nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "unsupported operand type(s) for divmod(): '%s' and '%s'", mp_obj_get_type_str(o1_in), mp_obj_get_type_str(o2_in)));
     }
diff --git a/py/emitnative.c b/py/emitnative.c
index 7385112..da0aa60 100644
--- a/py/emitnative.c
+++ b/py/emitnative.c
@@ -1063,14 +1063,14 @@
     //   if wrapped in byte_array, or something, allocates memory and fills it
     emit_native_pre(emit);
     emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items
-    emit_call_with_imm_arg(emit, MP_F_BUILD_TUPLE, mp_build_tuple, n_args, REG_ARG_1);
+    emit_call_with_imm_arg(emit, MP_F_BUILD_TUPLE, mp_obj_new_tuple, n_args, REG_ARG_1);
     emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new tuple
 }
 
 STATIC void emit_native_build_list(emit_t *emit, int n_args) {
     emit_native_pre(emit);
     emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items
-    emit_call_with_imm_arg(emit, MP_F_BUILD_LIST, mp_build_list, n_args, REG_ARG_1);
+    emit_call_with_imm_arg(emit, MP_F_BUILD_LIST, mp_obj_new_list, n_args, REG_ARG_1);
     emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new list
 }
 
@@ -1081,13 +1081,13 @@
     emit_access_stack(emit, list_index, &vtype_list, REG_ARG_1);
     assert(vtype_list == VTYPE_PYOBJ);
     assert(vtype_item == VTYPE_PYOBJ);
-    emit_call(emit, MP_F_LIST_APPEND, mp_list_append);
+    emit_call(emit, MP_F_LIST_APPEND, mp_obj_list_append);
     emit_post(emit);
 }
 
 STATIC void emit_native_build_map(emit_t *emit, int n_args) {
     emit_native_pre(emit);
-    emit_call_with_imm_arg(emit, MP_F_BUILD_MAP, mp_build_map, n_args, REG_ARG_1);
+    emit_call_with_imm_arg(emit, MP_F_BUILD_MAP, mp_obj_new_dict, n_args, REG_ARG_1);
     emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new map
 }
 
@@ -1097,7 +1097,7 @@
     assert(vtype_key == VTYPE_PYOBJ);
     assert(vtype_value == VTYPE_PYOBJ);
     assert(vtype_map == VTYPE_PYOBJ);
-    emit_call(emit, MP_F_STORE_MAP, mp_store_map);
+    emit_call(emit, MP_F_STORE_MAP, mp_obj_dict_store);
     emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // map
 }
 
@@ -1109,14 +1109,14 @@
     assert(vtype_map == VTYPE_PYOBJ);
     assert(vtype_key == VTYPE_PYOBJ);
     assert(vtype_value == VTYPE_PYOBJ);
-    emit_call(emit, MP_F_STORE_MAP, mp_store_map);
+    emit_call(emit, MP_F_STORE_MAP, mp_obj_dict_store);
     emit_post(emit);
 }
 
 STATIC void emit_native_build_set(emit_t *emit, int n_args) {
     emit_native_pre(emit);
     emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items
-    emit_call_with_imm_arg(emit, MP_F_BUILD_SET, mp_build_set, n_args, REG_ARG_1);
+    emit_call_with_imm_arg(emit, MP_F_BUILD_SET, mp_obj_new_set, n_args, REG_ARG_1);
     emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET); // new set
 }
 
@@ -1127,7 +1127,7 @@
     emit_access_stack(emit, set_index, &vtype_set, REG_ARG_1);
     assert(vtype_set == VTYPE_PYOBJ);
     assert(vtype_item == VTYPE_PYOBJ);
-    emit_call(emit, MP_F_STORE_SET, mp_store_set);
+    emit_call(emit, MP_F_STORE_SET, mp_obj_set_store);
     emit_post(emit);
 }
 
diff --git a/py/objdict.c b/py/objdict.c
index 01c7294..afd1d0d 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -33,7 +33,7 @@
 
 STATIC mp_obj_t dict_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
     // TODO create from an iterable!
-    return mp_build_map(0);
+    return mp_obj_new_dict(0);
 }
 
 STATIC mp_obj_t dict_unary_op(int op, mp_obj_t self_in) {
diff --git a/py/objstr.c b/py/objstr.c
index 751f93a..2ca2248 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -372,7 +372,7 @@
     while (s < top && splits != 0) {
         start = s;
         while (s < top && !is_ws(*s)) s++;
-        mp_list_append(res, mp_obj_new_str(start, s - start, false));
+        mp_obj_list_append(res, mp_obj_new_str(start, s - start, false));
         if (s >= top) {
             break;
         }
@@ -383,7 +383,7 @@
     }
 
     if (s < top) {
-        mp_list_append(res, mp_obj_new_str(s, top - s, false));
+        mp_obj_list_append(res, mp_obj_new_str(s, top - s, false));
     }
 
     return res;
diff --git a/py/runtime.c b/py/runtime.c
index f827fd8..53dccd8 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -72,10 +72,6 @@
     mp_emit_glue_deinit();
 }
 
-mp_obj_t mp_list_append(mp_obj_t self_in, mp_obj_t arg) {
-    return mp_obj_list_append(self_in, arg);
-}
-
 mp_obj_t mp_load_const_dec(qstr qstr) {
     DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
     uint len;
@@ -136,14 +132,6 @@
     }
 }
 
-mp_obj_t mp_get_cell(mp_obj_t cell) {
-    return mp_obj_cell_get(cell);
-}
-
-void mp_set_cell(mp_obj_t cell, mp_obj_t val) {
-    mp_obj_cell_set(cell, val);
-}
-
 void mp_store_name(qstr qstr, mp_obj_t obj) {
     DEBUG_OP_printf("store name %s <- %p\n", qstr_str(qstr), obj);
     mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = obj;
@@ -656,23 +644,6 @@
     return res;
 }
 
-mp_obj_t mp_build_tuple(int n_args, mp_obj_t *items) {
-    return mp_obj_new_tuple(n_args, items);
-}
-
-mp_obj_t mp_build_list(int n_args, mp_obj_t *items) {
-    return mp_obj_new_list(n_args, items);
-}
-
-mp_obj_t mp_build_set(int n_args, mp_obj_t *items) {
-    return mp_obj_new_set(n_args, items);
-}
-
-mp_obj_t mp_store_set(mp_obj_t set, mp_obj_t item) {
-    mp_obj_set_store(set, item);
-    return set;
-}
-
 // unpacked items are stored in reverse order into the array pointed to by items
 void mp_unpack_sequence(mp_obj_t seq_in, uint num, mp_obj_t *items) {
     uint seq_len;
@@ -713,15 +684,6 @@
     nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "too many values to unpack (expected %d)", num));
 }
 
-mp_obj_t mp_build_map(int n_args) {
-    return mp_obj_new_dict(n_args);
-}
-
-mp_obj_t mp_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value) {
-    // map should always be a dict
-    return mp_obj_dict_store(map, key, value);
-}
-
 mp_obj_t mp_load_attr(mp_obj_t base, qstr attr) {
     DEBUG_OP_printf("load attr %p.%s\n", base, qstr_str(attr));
     // use load_method
@@ -1057,13 +1019,13 @@
     mp_obj_is_true,
     mp_unary_op,
     mp_binary_op,
-    mp_build_tuple,
-    mp_build_list,
-    mp_list_append,
-    mp_build_map,
-    mp_store_map,
-    mp_build_set,
-    mp_store_set,
+    mp_obj_new_tuple,
+    mp_obj_new_list,
+    mp_obj_list_append,
+    mp_obj_new_dict,
+    mp_obj_dict_store,
+    mp_obj_new_set,
+    mp_obj_set_store,
     mp_make_function_from_id,
     mp_call_function_n_kw_for_native,
     mp_call_method_n_kw,
diff --git a/py/runtime.h b/py/runtime.h
index 78f5724..b817d61 100644
--- a/py/runtime.h
+++ b/py/runtime.h
@@ -28,9 +28,6 @@
 mp_obj_t mp_load_const_str(qstr qstr);
 mp_obj_t mp_load_const_bytes(qstr qstr);
 
-mp_obj_t mp_get_cell(mp_obj_t cell);
-void mp_set_cell(mp_obj_t cell, mp_obj_t val);
-
 mp_obj_t mp_make_function_from_id(uint unique_code_id, bool free_unique_code, mp_obj_t def_args, mp_obj_t def_kw_args);
 mp_obj_t mp_make_function_n(int n_args, void *fun); // fun must have the correct signature for n_args fixed arguments
 mp_obj_t mp_make_function_var(int n_args_min, mp_fun_var_t fun);
@@ -45,13 +42,7 @@
 mp_obj_t mp_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args);
 mp_obj_t mp_call_method_n_kw_var(bool have_self, uint n_args_n_kw, const mp_obj_t *args);
 
-mp_obj_t mp_build_tuple(int n_args, mp_obj_t *items);
-mp_obj_t mp_build_list(int n_args, mp_obj_t *items);
-mp_obj_t mp_list_append(mp_obj_t list, mp_obj_t arg);
-mp_obj_t mp_build_set(int n_args, mp_obj_t *items);
-mp_obj_t mp_store_set(mp_obj_t set, mp_obj_t item);
 void mp_unpack_sequence(mp_obj_t seq, uint num, mp_obj_t *items);
-mp_obj_t mp_build_map(int n_args);
 mp_obj_t mp_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value);
 mp_obj_t mp_load_attr(mp_obj_t base, qstr attr);
 void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest);
diff --git a/py/vm.c b/py/vm.c
index 20388ec..8aec2e1 100644
--- a/py/vm.c
+++ b/py/vm.c
@@ -243,7 +243,7 @@
 
                     case MP_BC_LOAD_DEREF:
                         DECODE_UINT;
-                        PUSH(mp_get_cell(fastn[-unum]));
+                        PUSH(mp_obj_cell_get(fastn[-unum]));
                         break;
 
                     case MP_BC_LOAD_NAME:
@@ -290,7 +290,7 @@
 
                     case MP_BC_STORE_DEREF:
                         DECODE_UINT;
-                        mp_set_cell(fastn[-unum], POP());
+                        mp_obj_cell_set(fastn[-unum], POP());
                         break;
 
                     case MP_BC_STORE_NAME:
@@ -580,49 +580,49 @@
                     case MP_BC_BUILD_TUPLE:
                         DECODE_UINT;
                         sp -= unum - 1;
-                        SET_TOP(mp_build_tuple(unum, sp));
+                        SET_TOP(mp_obj_new_tuple(unum, sp));
                         break;
 
                     case MP_BC_BUILD_LIST:
                         DECODE_UINT;
                         sp -= unum - 1;
-                        SET_TOP(mp_build_list(unum, sp));
+                        SET_TOP(mp_obj_new_list(unum, sp));
                         break;
 
                     case MP_BC_LIST_APPEND:
                         DECODE_UINT;
                         // I think it's guaranteed by the compiler that sp[unum] is a list
-                        mp_list_append(sp[-unum], sp[0]);
+                        mp_obj_list_append(sp[-unum], sp[0]);
                         sp--;
                         break;
 
                     case MP_BC_BUILD_MAP:
                         DECODE_UINT;
-                        PUSH(mp_build_map(unum));
+                        PUSH(mp_obj_new_dict(unum));
                         break;
 
                     case MP_BC_STORE_MAP:
                         sp -= 2;
-                        mp_store_map(sp[0], sp[2], sp[1]);
+                        mp_obj_dict_store(sp[0], sp[2], sp[1]);
                         break;
 
                     case MP_BC_MAP_ADD:
                         DECODE_UINT;
                         // I think it's guaranteed by the compiler that sp[-unum - 1] is a map
-                        mp_store_map(sp[-unum - 1], sp[0], sp[-1]);
+                        mp_obj_dict_store(sp[-unum - 1], sp[0], sp[-1]);
                         sp -= 2;
                         break;
 
                     case MP_BC_BUILD_SET:
                         DECODE_UINT;
                         sp -= unum - 1;
-                        SET_TOP(mp_build_set(unum, sp));
+                        SET_TOP(mp_obj_new_set(unum, sp));
                         break;
 
                     case MP_BC_SET_ADD:
                         DECODE_UINT;
                         // I think it's guaranteed by the compiler that sp[-unum] is a set
-                        mp_store_set(sp[-unum], sp[0]);
+                        mp_obj_set_store(sp[-unum], sp[0]);
                         sp--;
                         break;