diff --git a/src/context.c b/src/context.c
index a4a9049..a81e95f 100644
--- a/src/context.c
+++ b/src/context.c
@@ -198,10 +198,8 @@
     LY_CHECK_GOTO(ret = lys_parse_load(ctx, name, revision, &unres, &result), cleanup);
 
     /* implement */
-    LY_CHECK_GOTO(ret = lys_implement(result, features, &unres), cleanup);
-
-    /* resolve unres and revert, if needed */
-    LY_CHECK_GOTO(ret = lys_compile_unres_glob(ctx, &unres), cleanup);
+    ret = _lys_set_implemented(mod, features, &unres);
+    LY_CHECK_GOTO(ret, cleanup);
 
 cleanup:
     if (ret) {
@@ -510,9 +508,12 @@
     for (i = 0; i < ctx->list.count; ++i) {
         mod = ctx->list.objs[i];
         if (mod->to_compile) {
-            /* if was not implemented, will be */
-            mod->implemented = 1;
+            assert(mod->implemented);
 
+            /* just unset the flag, it is not used for anything currently */
+            mod->to_compile = 0;
+
+            /* some modules were changed and need to be (re)compiled */
             recompile = 1;
         }
     }
@@ -522,18 +523,8 @@
         return LY_SUCCESS;
     }
 
-    /* recompile */
-    LY_CHECK_RET(lys_recompile(ctx, 1));
-
-    /* everything is fine, clear the flags */
-    for (i = 0; i < ctx->list.count; ++i) {
-        mod = ctx->list.objs[i];
-        if (mod->to_compile) {
-            mod->to_compile = 0;
-        }
-    }
-
-    return LY_SUCCESS;
+    /* (re)compile all the implemented modules */
+    return lys_recompile(ctx, 1);
 }
 
 API uint16_t
@@ -1203,13 +1194,22 @@
 API void
 ly_ctx_destroy(struct ly_ctx *ctx)
 {
+    struct lys_module *mod;
+
     if (!ctx) {
         return;
     }
 
     /* models list */
     for ( ; ctx->list.count; ctx->list.count--) {
+        mod = ctx->list.objs[ctx->list.count - 1];
+
         /* remove the module */
+        if (mod->implemented) {
+            mod->implemented = 0;
+            lysc_module_free(mod->compiled);
+            mod->compiled = NULL;
+        }
         lys_module_free(ctx->list.objs[ctx->list.count - 1]);
     }
     free(ctx->list.objs);
diff --git a/src/plugins_types.c b/src/plugins_types.c
index adfeb17..df33bd4 100644
--- a/src/plugins_types.c
+++ b/src/plugins_types.c
@@ -751,13 +751,11 @@
 API LY_ERR
 lyplg_type_make_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
 {
-    LY_CHECK_RET(lys_implement(mod, features, unres));
-
-    if (unres->recompile) {
-        return LY_ERECOMPILE;
+    if (mod->implemented) {
+        return LY_SUCCESS;
     }
 
-    return LY_SUCCESS;
+    return lys_implement(mod, features, unres);
 }
 
 API LY_ERR
diff --git a/src/schema_compile.c b/src/schema_compile.c
index 1585f2f..a62ba98 100644
--- a/src/schema_compile.c
+++ b/src/schema_compile.c
@@ -1486,35 +1486,40 @@
 }
 
 /**
- * @brief Compile identites in the current module and all its submodules.
+ * @brief Compile identites in a module and all its submodules.
  *
- * @param[in] ctx Compile context.
+ * @param[in] mod Module to process.
  * @return LY_ERR value.
  */
 static LY_ERR
-lys_compile_identities(struct lysc_ctx *ctx)
+lys_compile_identities(struct lys_module *mod)
 {
-    LY_ERR ret = LY_SUCCESS;
+    struct lysc_ctx ctx = {0};
     struct lysp_submodule *submod;
     struct lysp_module *orig_pmod = ctx->pmod;
     LY_ARRAY_COUNT_TYPE u;
 
-    if (ctx->cur_mod->parsed->identities) {
-        LY_CHECK_GOTO(ret = lys_compile_identities_derived(ctx, ctx->cur_mod->parsed->identities,
-                &ctx->cur_mod->identities), cleanup);
+    /* prepare context */
+    ctx.ctx = mod->ctx;
+    ctx.cur_mod = mod;
+    ctx.pmod = mod->parsed;
+    ctx.path_len = 1;
+    ctx.path[0] = '/';
+
+    if (mod->parsed->identities) {
+        LY_CHECK_RET(lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities));
     }
-    lysc_update_path(ctx, NULL, "{submodule}");
-    LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
-        submod = ctx->cur_mod->parsed->includes[u].submodule;
+    lysc_update_path(&ctx, NULL, "{submodule}");
+    LY_ARRAY_FOR(mod->parsed->includes, u) {
+        submod = mod->parsed->includes[u].submodule;
         if (submod->identities) {
-            ctx->pmod = (struct lysp_module *)submod;
-            lysc_update_path(ctx, NULL, submod->name);
-            ret = lys_compile_identities_derived(ctx, submod->identities, &ctx->cur_mod->identities);
-            lysc_update_path(ctx, NULL, NULL);
-            LY_CHECK_GOTO(ret, cleanup);
+            ctx.pmod = (struct lysp_module *)submod;
+            lysc_update_path(&ctx, NULL, submod->name);
+            LY_CHECK_RET(lys_compile_identities_derived(&ctx, submod->identities, &mod->identities));
+            lysc_update_path(&ctx, NULL, NULL);
         }
     }
-    lysc_update_path(ctx, NULL, NULL);
+    lysc_update_path(&ctx, NULL, NULL);
 
 cleanup:
     ctx->pmod = orig_pmod;
@@ -1543,6 +1548,8 @@
     for (idx = 0; idx < ctx->list.count; ++idx) {
         mod = ctx->list.objs[idx];
         if (mod->compiled) {
+            assert(mod->implemented);
+
             /* free the module */
             lysc_module_free(mod->compiled);
             mod->compiled = NULL;
@@ -1579,42 +1586,16 @@
 cleanup:
     if (!log) {
         ly_log_options(prev_lo);
+        if (ret) {
+            LOGERR(mod->ctx, ret, "Recompilation of module \"%s\" failed.", mod->name);
+        }
     }
-    lys_compile_unres_glob_erase(ctx, &unres);
+    lys_compile_unres_glob_erase(ctx, &unres, 0);
     return ret;
 }
 
-/**
- * @brief Check whether a module does not have any (recursive) compiled import.
- *
- * @param[in] mod Module to examine.
- * @return Whether the module has a compiled imported module.
- */
-static ly_bool
-lys_has_compiled_import_r(struct lys_module *mod)
-{
-    LY_ARRAY_COUNT_TYPE u;
-
-    LY_ARRAY_FOR(mod->parsed->imports, u) {
-        if (!mod->parsed->imports[u].module->implemented) {
-            continue;
-        }
-
-        if (mod->parsed->imports[u].module->compiled) {
-            return 1;
-        }
-
-        /* recursive */
-        if (lys_has_compiled_import_r(mod->parsed->imports[u].module)) {
-            return 1;
-        }
-    }
-
-    return 0;
-}
-
 LY_ERR
-lys_compile(struct lys_module *mod, uint32_t options, ly_bool recompile, struct lys_glob_unres *unres)
+lys_compile(struct lys_module *mod, uint32_t options, struct lys_glob_unres *unres)
 {
     struct lysc_ctx ctx = {0};
     struct lysc_module *mod_c = NULL;
@@ -1641,29 +1622,6 @@
     ctx.path[0] = '/';
     ctx.unres = unres;
 
-    /* skip compilation tasks that need to be performed only once for implemented modules */
-    if (!recompile) {
-        /* identities */
-        LY_CHECK_GOTO(ret = lys_compile_identities(&ctx), cleanup);
-
-        /* augments and deviations */
-        LY_CHECK_GOTO(ret = lys_precompile_augments_deviations(&ctx), cleanup);
-
-        if (!unres->recompile && !unres->full_compilation) {
-            /* check whether this module may reference any already-compiled modules */
-            if (lys_has_compiled_import_r(mod)) {
-                /* it may and we need even disabled nodes in those modules, recompile them */
-                unres->recompile = 1;
-            }
-        }
-
-        if (unres->recompile) {
-            /* we need the context recompiled */
-            goto cleanup;
-        }
-    }
-
-    /* now the actual compilation will take place */
     ++mod->ctx->change_count;
     mod->compiled = mod_c = calloc(1, sizeof *mod_c);
     LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
@@ -1763,3 +1721,98 @@
     }
     return ret;
 }
+
+/**
+ * @brief Check whether a module does not have any (recursive) compiled import.
+ *
+ * @param[in] mod Module to examine.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERECOMPILE on required recompilation.
+ * @return LY_ERR on error.
+ */
+static LY_ERR
+lys_has_compiled_import_r(struct lys_module *mod)
+{
+    LY_ARRAY_COUNT_TYPE u;
+
+    LY_ARRAY_FOR(mod->parsed->imports, u) {
+        if (!mod->parsed->imports[u].module->implemented) {
+            continue;
+        }
+
+        if (mod->parsed->imports[u].module->compiled) {
+            return LY_ERECOMPILE;
+        }
+
+        /* recursive */
+        LY_CHECK_RET(lys_has_compiled_import_r(mod->parsed->imports[u].module));
+    }
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
+{
+    LY_ERR ret;
+    struct lys_module *m;
+
+    assert(!mod->implemented);
+
+    /* we have module from the current context */
+    m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
+    if (m) {
+        assert(m != mod);
+
+        /* check collision with other implemented revision */
+        LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
+                mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
+        return LY_EDENIED;
+    }
+
+    /* set features */
+    ret = lys_set_features(mod->parsed, features);
+    if (ret && (ret != LY_EEXIST)) {
+        return ret;
+    }
+
+    /* compile identities */
+    LY_CHECK_RET(lys_compile_identities(mod));
+
+    /* mark target modules with our augments and deviations */
+    ret = lys_precompile_augments_deviations(mod, unres);
+    LY_CHECK_RET(ret && (ret != LY_ERECOMPILE), ret);
+
+    /*
+     * mark the module implemented, which means
+     * 1) to (re)compile it only ::lys_compile() call is needed
+     * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE)
+     *    but there can be some unres items added that do
+     */
+    mod->implemented = 1;
+
+    /* add the module into newly implemented module set */
+    LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
+
+    if (mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE) {
+        /* do not actually compile the module yet */
+        mod->to_compile = 1;
+        return LY_SUCCESS;
+    } else if (ret == LY_ERECOMPILE) {
+        /* we cannot compile the module yet */
+        return ret;
+    }
+
+    if (!unres->full_compilation) {
+        /* check whether this module may reference any already-compiled modules */
+        LY_CHECK_RET(lys_has_compiled_import_r(mod));
+    }
+
+    /* compile the schema */
+    LY_CHECK_RET(lys_compile(mod, 0, unres));
+
+    /* new module is implemented and compiled */
+    unres->full_compilation = 0;
+
+    return LY_SUCCESS;
+}
diff --git a/src/schema_compile.h b/src/schema_compile.h
index 3206b39..aba8094 100644
--- a/src/schema_compile.h
+++ b/src/schema_compile.h
@@ -276,16 +276,31 @@
 LY_ERR lys_recompile(struct ly_ctx *ctx, ly_bool log);
 
 /**
- * @brief Compile printable schema into a validated schema linking all the references.
+ * @brief Compile schema into a validated schema linking all the references.
+ *
+ * Implemented flag of @p mod must be set meaning this function should be called only if the module
+ * is being recompiled, otherwise call ::lys_implement().
  *
  * @param[in] mod Pointer to the schema structure holding pointers to both schema structure types. The ::lys_module#parsed
  * member is used as input and ::lys_module#compiled is used to hold the result of the compilation.
  * @param[in] options Various options to modify compiler behavior, see [compile flags](@ref scflags).
- * @param[in] recompile Whether @p mod is compiled for the first time or only recompiled.
- * @param[in,out] unres Global unres structure for newly implemented modules. If `recompile` was set, @p mod
- * was actually not compiled because there is at least one compiled imported module that must be recompiled first.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ * @param[in,out] unres Global unres structure to add to.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERR on error.
  */
-LY_ERR lys_compile(struct lys_module *mod, uint32_t options, ly_bool recompile, struct lys_glob_unres *unres);
+LY_ERR lys_compile(struct lys_module *mod, uint32_t options, struct lys_glob_unres *unres);
+
+/**
+ * @brief Implement a single module, can be called recursively.
+ *
+ * @param[in] mod Module to implement.
+ * @param[in] features Features to set, see ::lys_set_features().
+ * @param[in,out] unres Global unres to add to.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERECOMPILE on required recompilation, @p mod implemented flag is kept and
+ * is left in @p unres implementing set so that it is known that the next compilation is recompilation.
+ * @return LY_ERR on error.
+ */
+LY_ERR lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres);
 
 #endif /* LY_SCHEMA_COMPILE_H_ */
diff --git a/src/schema_compile_amend.c b/src/schema_compile_amend.c
index e571546..aab32bb 100644
--- a/src/schema_compile_amend.c
+++ b/src/schema_compile_amend.c
@@ -2173,32 +2173,39 @@
 }
 
 LY_ERR
-lys_precompile_augments_deviations(struct lysc_ctx *ctx)
+lys_precompile_augments_deviations(struct lys_module *mod, struct lys_glob_unres *unres)
 {
     LY_ERR ret = LY_SUCCESS;
     LY_ARRAY_COUNT_TYPE u, v;
-    const struct lysp_module *mod_p;
-    struct lysp_module *orig_pmod;
-    struct lys_module *mod;
+    struct lysc_ctx ctx = {0};
+    struct lysp_module *mod_p;
+    struct lys_module *m;
     struct lysp_submodule *submod;
     struct lysp_node_augment *aug;
     uint32_t idx;
     struct ly_set mod_set = {0}, set = {0};
 
-    orig_pmod = ctx->pmod;
-    mod_p = ctx->cur_mod->parsed;
+    mod_p = mod->parsed;
+
+    /* prepare context */
+    ctx.ctx = mod->ctx;
+    ctx.cur_mod = mod;
+    ctx.pmod = mod_p;
+    ctx.path_len = 1;
+    ctx.path[0] = '/';
+    ctx.unres = unres;
 
     LY_LIST_FOR(mod_p->augments, aug) {
         /* get target module */
-        lysc_update_path(ctx, NULL, "{augment}");
-        lysc_update_path(ctx, NULL, aug->nodeid);
-        ret = lys_nodeid_mod_check(ctx, aug->nodeid, 1, &set, NULL, &mod);
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(&ctx, NULL, "{augment}");
+        lysc_update_path(&ctx, NULL, aug->nodeid);
+        ret = lys_nodeid_mod_check(&ctx, aug->nodeid, 1, &set, NULL, &m);
+        lysc_update_path(&ctx, NULL, NULL);
+        lysc_update_path(&ctx, NULL, NULL);
         LY_CHECK_GOTO(ret, cleanup);
 
         /* add this module into the target module augmented_by, if not there and implemented */
-        if ((lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->augmented_by) != LY_EEXIST) ||
+        if ((lys_array_add_mod_ref(&ctx, mod, &m->augmented_by) != LY_EEXIST) ||
                 !lys_precompile_mod_set_all_implemented(&set)) {
             LY_CHECK_GOTO(ret = ly_set_merge(&mod_set, &set, 0, NULL), cleanup);
         }
@@ -2207,15 +2214,15 @@
 
     LY_ARRAY_FOR(mod_p->deviations, u) {
         /* get target module */
-        lysc_update_path(ctx, NULL, "{deviation}");
-        lysc_update_path(ctx, NULL, mod_p->deviations[u].nodeid);
-        ret = lys_nodeid_mod_check(ctx, mod_p->deviations[u].nodeid, 1, &set, NULL, &mod);
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(&ctx, NULL, "{deviation}");
+        lysc_update_path(&ctx, NULL, mod_p->deviations[u].nodeid);
+        ret = lys_nodeid_mod_check(&ctx, mod_p->deviations[u].nodeid, 1, &set, NULL, &m);
+        lysc_update_path(&ctx, NULL, NULL);
+        lysc_update_path(&ctx, NULL, NULL);
         LY_CHECK_GOTO(ret, cleanup);
 
         /* add this module into the target module deviated_by, if not there and implemented */
-        if ((lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->deviated_by) != LY_EEXIST) ||
+        if ((lys_array_add_mod_ref(&ctx, mod, &m->deviated_by) != LY_EEXIST) ||
                 !lys_precompile_mod_set_all_implemented(&set)) {
             LY_CHECK_GOTO(ret = ly_set_merge(&mod_set, &set, 0, NULL), cleanup);
         }
@@ -2225,17 +2232,17 @@
     /* the same for augments and deviations in submodules */
     LY_ARRAY_FOR(mod_p->includes, v) {
         submod = mod_p->includes[v].submodule;
-        ctx->pmod = (struct lysp_module *)submod;
+        ctx.pmod = (struct lysp_module *)submod;
 
         LY_LIST_FOR(submod->augments, aug) {
-            lysc_update_path(ctx, NULL, "{augment}");
-            lysc_update_path(ctx, NULL, aug->nodeid);
-            ret = lys_nodeid_mod_check(ctx, aug->nodeid, 1, &set, NULL, &mod);
-            lysc_update_path(ctx, NULL, NULL);
-            lysc_update_path(ctx, NULL, NULL);
+            lysc_update_path(&ctx, NULL, "{augment}");
+            lysc_update_path(&ctx, NULL, aug->nodeid);
+            ret = lys_nodeid_mod_check(&ctx, aug->nodeid, 1, &set, NULL, &m);
+            lysc_update_path(&ctx, NULL, NULL);
+            lysc_update_path(&ctx, NULL, NULL);
             LY_CHECK_GOTO(ret, cleanup);
 
-            if ((lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->augmented_by) != LY_EEXIST) ||
+            if ((lys_array_add_mod_ref(&ctx, mod, &m->augmented_by) != LY_EEXIST) ||
                     !lys_precompile_mod_set_all_implemented(&set)) {
                 LY_CHECK_GOTO(ret = ly_set_merge(&mod_set, &set, 0, NULL), cleanup);
             }
@@ -2243,14 +2250,14 @@
         }
 
         LY_ARRAY_FOR(submod->deviations, u) {
-            lysc_update_path(ctx, NULL, "{deviation}");
-            lysc_update_path(ctx, NULL, submod->deviations[u].nodeid);
-            ret = lys_nodeid_mod_check(ctx, submod->deviations[u].nodeid, 1, &set, NULL, &mod);
-            lysc_update_path(ctx, NULL, NULL);
-            lysc_update_path(ctx, NULL, NULL);
+            lysc_update_path(&ctx, NULL, "{deviation}");
+            lysc_update_path(&ctx, NULL, submod->deviations[u].nodeid);
+            ret = lys_nodeid_mod_check(&ctx, submod->deviations[u].nodeid, 1, &set, NULL, &m);
+            lysc_update_path(&ctx, NULL, NULL);
+            lysc_update_path(&ctx, NULL, NULL);
             LY_CHECK_GOTO(ret, cleanup);
 
-            if ((lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->deviated_by) != LY_EEXIST) ||
+            if ((lys_array_add_mod_ref(&ctx, mod, &m->deviated_by) != LY_EEXIST) ||
                     !lys_precompile_mod_set_all_implemented(&set)) {
                 LY_CHECK_GOTO(ret = ly_set_merge(&mod_set, &set, 0, NULL), cleanup);
             }
@@ -2263,33 +2270,29 @@
         idx = mod_set.count;
         do {
             --idx;
-            mod = mod_set.objs[idx];
+            m = mod_set.objs[idx];
 
-            if (mod == ctx->cur_mod) {
+            if (m == mod) {
                 /* will be applied normally later */
                 continue;
             }
 
-            if (!mod->implemented) {
+            if (!m->implemented) {
                 /* implement (compile) the target module with our augments/deviations */
-                LY_CHECK_GOTO(ret = lys_implement(mod, NULL, ctx->unres), cleanup);
-            } else if (!ctx->unres->full_compilation) {
+                LY_CHECK_GOTO(ret = lys_implement(m, NULL, unres), cleanup);
+            } else if (!unres->full_compilation) {
                 /* target module was already compiled, we need to recompile it */
-                ctx->unres->recompile = 1;
+                ret = LY_ERECOMPILE;
+                goto cleanup;
             }
             /* else the module is implemented and was compiled in this compilation run or will yet be;
              * we actually do not need the module compiled now because its compiled nodes will not be accessed,
              * augments/deviations are applied during the target module compilation and the rest is in global unres */
 
-            if (ctx->unres->recompile) {
-                /* we need some module recompiled and cannot continue */
-                goto cleanup;
-            }
         } while (idx);
     }
 
 cleanup:
-    ctx->pmod = orig_pmod;
     ly_set_erase(&set, NULL);
     ly_set_erase(&mod_set, NULL);
     return ret;
diff --git a/src/schema_compile_amend.h b/src/schema_compile_amend.h
index 98da72e..3dca22c 100644
--- a/src/schema_compile_amend.h
+++ b/src/schema_compile_amend.h
@@ -23,6 +23,7 @@
 struct lysc_node;
 struct lysc_ctx;
 struct lysp_node_uses;
+struct lys_glob_unres;
 struct lys_module;
 
 /**
@@ -155,14 +156,16 @@
 LY_ERR lys_precompile_own_deviations(struct lysc_ctx *ctx);
 
 /**
- * @brief Compile top-level augments and deviations defined in the current module.
- * Generally, just add the module refence to the target modules. But in case
- * of foreign augments, they are directly applied.
+ * @brief Compile top-level augments and deviations in a module and all its submodules.
+ * Adds the module reference to the target modules and if not implemented, implement them.
  *
- * @param[in] ctx Compile context.
- * @return LY_ERR value.
+ * @param[in] mod Module to process.
+ * @param[in] unres Global unres to use.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERECOMPILE on required recompilation.
+ * @return LY_ERR on error.
  */
-LY_ERR lys_precompile_augments_deviations(struct lysc_ctx *ctx);
+LY_ERR lys_precompile_augments_deviations(struct lys_module *mod, struct lys_glob_unres *unres);
 
 /**
  * @brief Revert precompilation of module augments and deviations. Meaning remove its reference from
diff --git a/src/tree_schema.c b/src/tree_schema.c
index cde2fa2..986e83c 100644
--- a/src/tree_schema.c
+++ b/src/tree_schema.c
@@ -798,61 +798,10 @@
 }
 
 LY_ERR
-lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
-{
-    LY_ERR ret;
-    struct lys_module *m;
-
-    if (mod->implemented) {
-        /* nothing to do */
-        return LY_SUCCESS;
-    }
-
-    /* we have module from the current context */
-    m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
-    if (m) {
-        assert(m != mod);
-
-        /* check collision with other implemented revision */
-        LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
-                mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
-        return LY_EDENIED;
-    }
-
-    /* set features */
-    ret = lys_set_features(mod->parsed, features);
-    if (ret && (ret != LY_EEXIST)) {
-        return ret;
-    }
-
-    if (mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE) {
-        /* do not compile the module yet */
-        mod->to_compile = 1;
-        return LY_SUCCESS;
-    }
-
-    /* add the module into newly implemented module set */
-    LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
-
-    /* mark the module implemented, check for collision was already done */
-    mod->implemented = 1;
-
-    /* compile the schema */
-    LY_CHECK_RET(lys_compile(mod, 0, 0, unres));
-
-    /* new module is implemented and compiled */
-    unres->full_compilation = 0;
-
-    return LY_SUCCESS;
-}
-
-API LY_ERR
-lys_set_implemented(struct lys_module *mod, const char **features)
+_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
 {
     LY_ERR ret = LY_SUCCESS, r;
-    struct lys_glob_unres unres = {0};
-
-    LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
+    uint32_t i;
 
     if (mod->implemented) {
         /* mod is already implemented, set the features */
@@ -875,19 +824,63 @@
         }
     }
 
-    /* implement this module and any other required modules, recursively */
-    ret = lys_implement(mod, features, &unres);
+    /* implement */
+    ret = lys_implement(mod, features, unres);
+    if (ret == LY_ERECOMPILE) {
+        /* recompile */
+        LY_CHECK_GOTO(ret = lys_recompile(mod->ctx, 1), cleanup);
 
-    /* the first module being implemented is finished, resolve global unres, consolidate the set */
-    if (!ret) {
-        ret = lys_compile_unres_glob(mod->ctx, &unres);
+        /* reset unres, it is no longer valid after recompilation and recompilation has actually resolved it all */
+        lys_compile_unres_glob_erase(mod->ctx, unres, 1);
+        unres->full_compilation = 1;
+    } else if (ret) {
+        goto cleanup;
     }
+
+    if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
+        /* implement all the imports as well */
+        for (i = 0; i < unres->creating.count; ++i) {
+            mod = unres->creating.objs[i];
+            if (mod->implemented) {
+                continue;
+            }
+
+            ret = lys_implement(mod, NULL, unres);
+            if (ret == LY_ERECOMPILE) {
+                LY_CHECK_GOTO(ret = lys_recompile(mod->ctx, 1), cleanup);
+
+                lys_compile_unres_glob_erase(mod->ctx, unres, 1);
+                unres->full_compilation = 1;
+            } else if (ret) {
+                goto cleanup;
+            }
+        }
+    }
+
+    /* resolve unres */
+    LY_CHECK_GOTO(ret = lys_compile_unres_glob(mod->ctx, unres), cleanup);
+
+cleanup:
+    return ret;
+}
+
+API LY_ERR
+lys_set_implemented(struct lys_module *mod, const char **features)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lys_glob_unres unres = {0};
+
+    LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
+
+    /* implement */
+    ret = _lys_set_implemented(mod, features, &unres);
+    LY_CHECK_GOTO(ret, cleanup);
+
+cleanup:
     if (ret) {
-        /* failure, full compile revert */
         lys_compile_unres_glob_revert(mod->ctx, &unres);
     }
-
-    lys_compile_unres_glob_erase(mod->ctx, &unres);
+    lys_compile_unres_glob_erase(mod->ctx, &unres, 0);
     return ret;
 }
 
@@ -1437,7 +1430,7 @@
 API LY_ERR
 lys_parse(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const char **features, const struct lys_module **module)
 {
-    LY_ERR ret;
+    LY_ERR ret = LY_SUCCESS;
     struct lys_module *mod;
     struct lys_glob_unres unres = {0};
 
@@ -1457,11 +1450,7 @@
     LY_CHECK_GOTO(ret, cleanup);
 
     /* implement */
-    ret = lys_implement(mod, features, &unres);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    /* resolve global unres */
-    ret = lys_compile_unres_glob(ctx, &unres);
+    ret = _lys_set_implemented(mod, features, &unres);
     LY_CHECK_GOTO(ret, cleanup);
 
 cleanup:
diff --git a/src/tree_schema_internal.h b/src/tree_schema_internal.h
index 9501ee8..a39e67c 100644
--- a/src/tree_schema_internal.h
+++ b/src/tree_schema_internal.h
@@ -524,15 +524,15 @@
 const char *lys_datatype2str(LY_DATA_TYPE basetype);
 
 /**
- * @brief Implement a module, can be called recursively.
+ * @brief Implement a module and resolve all global unres.
  *
  * @param[in] mod Module to implement.
  * @param[in] features Features to set, see ::lys_set_features().
- * @param[in,out] unres Global unres to add to.
- * @return LY_ERECOMPILE if unres->recompile dep set needs to be recompiled.
+ * @param[in] unres Global unres with all the created modules.
+ * @return LY_SUCCESS on success.
  * @return LY_ERR on error.
  */
-LY_ERR lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres);
+LY_ERR _lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres);
 
 typedef LY_ERR (*lys_custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod,
         void *check_data);