diff --git a/include/shell/shell.h b/include/shell/shell.h
index 04b07b83d50..fdb4182f0cb 100644
--- a/include/shell/shell.h
+++ b/include/shell/shell.h
@@ -615,31 +615,59 @@ struct shell_stats {
 #endif /* CONFIG_SHELL_STATS */
 
 /**
- * @internal @brief Flags for internal shell usage.
+ * @internal @brief Flags for shell backend configuration.
  */
-struct shell_flags {
+struct shell_backend_config_flags {
 	uint32_t insert_mode :1; /*!< Controls insert mode for text introduction.*/
-	uint32_t use_colors  :1; /*!< Controls colored syntax.*/
 	uint32_t echo        :1; /*!< Controls shell echo.*/
 	uint32_t obscure     :1; /*!< If echo on, print asterisk instead */
-	uint32_t processing  :1; /*!< Shell is executing process function.*/
-	uint32_t tx_rdy      :1;
 	uint32_t mode_delete :1; /*!< Operation mode of backspace key */
-	uint32_t history_exit:1; /*!< Request to exit history mode */
-	uint32_t last_nl     :8; /*!< Last received new line character */
-	uint32_t cmd_ctx     :1; /*!< Shell is executing command */
-	uint32_t print_noinit:1; /*!< Print request from not initialized shell*/
+	uint32_t use_colors  :1; /*!< Controls colored syntax.*/
+	uint32_t use_vt100   :1; /*!< Controls VT100 commands usage in shell */
 };
 
-BUILD_ASSERT((sizeof(struct shell_flags) == sizeof(uint32_t)),
+BUILD_ASSERT((sizeof(struct shell_backend_config_flags) == sizeof(uint32_t)),
+	     "Structure must fit in 4 bytes");
+
+/**
+ * @internal @brief Default backend configuration.
+ */
+#define SHELL_DEFAULT_BACKEND_CONFIG_FLAGS	\
+{						\
+	.insert_mode	= 0,			\
+	.echo		= 1,			\
+	.obscure	= 0,			\
+	.mode_delete	= 1,			\
+	.use_colors	= 1,			\
+	.use_vt100	= 1,			\
+};
+
+struct shell_backend_ctx_flags {
+	uint32_t processing   :1; /*!< Shell is executing process function.*/
+	uint32_t tx_rdy       :1;
+	uint32_t history_exit :1; /*!< Request to exit history mode */
+	uint32_t last_nl      :8; /*!< Last received new line character */
+	uint32_t cmd_ctx      :1; /*!< Shell is executing command */
+	uint32_t print_noinit :1; /*!< Print request from not initialized shell*/
+};
+
+BUILD_ASSERT((sizeof(struct shell_backend_ctx_flags) == sizeof(uint32_t)),
 	     "Structure must fit in 4 bytes");
 
 /**
  * @internal @brief Union for internal shell usage.
  */
-union shell_internal {
+union shell_backend_cfg {
 	uint32_t value;
-	struct shell_flags flags;
+	struct shell_backend_config_flags flags;
+};
+
+/**
+ * @internal @brief Union for internal shell usage.
+ */
+union shell_backend_ctx {
+	uint32_t value;
+	struct shell_backend_ctx_flags flags;
 };
 
 enum shell_signal {
@@ -695,7 +723,8 @@ struct shell_ctx {
 	/*!< Printf buffer size.*/
 	char printf_buff[CONFIG_SHELL_PRINTF_BUFF_SIZE];
 
-	volatile union shell_internal internal; /*!< Internal shell data.*/
+	volatile union shell_backend_cfg cfg;
+	volatile union shell_backend_ctx ctx;
 
 	struct k_poll_signal signals[SHELL_SIGNALS];
 
@@ -796,7 +825,8 @@ extern void z_shell_print_stream(const void *user_ctx, const char *data,
  *
  * @param[in] shell		Pointer to shell instance.
  * @param[in] transport_config	Transport configuration during initialization.
- * @param[in] use_colors	Enables colored prints.
+ * @param[in] cfg_flags		Initial backend configuration flags.
+ *				Shell will copy this data.
  * @param[in] log_backend	If true, the console will be used as logger
  *				backend.
  * @param[in] init_log_level	Default severity level for the logger.
@@ -804,7 +834,8 @@ extern void z_shell_print_stream(const void *user_ctx, const char *data,
  * @return Standard error code.
  */
 int shell_init(const struct shell *shell, const void *transport_config,
-	       bool use_colors, bool log_backend, uint32_t init_log_level);
+	       struct shell_backend_config_flags cfg_flags,
+	       bool log_backend, uint32_t init_log_level);
 
 /**
  * @brief Uninitializes the transport layer and the internal shell state.
diff --git a/samples/subsys/shell/shell_module/src/uart_reinit.c b/samples/subsys/shell/shell_module/src/uart_reinit.c
index 9096355cf64..0414b1ed548 100644
--- a/samples/subsys/shell/shell_module/src/uart_reinit.c
+++ b/samples/subsys/shell/shell_module/src/uart_reinit.c
@@ -16,7 +16,9 @@ void shell_init_from_work(struct k_work *work)
 		(CONFIG_SHELL_BACKEND_SERIAL_LOG_LEVEL > LOG_LEVEL_DBG) ?
 		CONFIG_LOG_MAX_LEVEL : CONFIG_SHELL_BACKEND_SERIAL_LOG_LEVEL;
 
-	shell_init(shell_backend_uart_get_ptr(), dev, true, log_backend, level);
+	shell_init(shell_backend_uart_get_ptr(), dev,
+		   shell_backend_uart_get_ptr()->ctx->cfg.flags,
+		   log_backend, level);
 }
 
 static void shell_reinit_trigger(void)
diff --git a/subsys/shell/shell.c b/subsys/shell/shell.c
index 7feb6fc2714..7ace47de310 100644
--- a/subsys/shell/shell.c
+++ b/subsys/shell/shell.c
@@ -1176,51 +1176,58 @@ static void shell_log_process(const struct shell *shell)
 	} while (processed && !signaled);
 }
 
-static int instance_init(const struct shell *shell, const void *p_config,
-			 bool use_colors)
+static int instance_init(const struct shell *sh,
+			 const void *transport_config,
+			 struct shell_backend_config_flags cfg_flags)
 {
-	__ASSERT_NO_MSG((shell->shell_flag == SHELL_FLAG_CRLF_DEFAULT) ||
-			(shell->shell_flag == SHELL_FLAG_OLF_CRLF));
+	__ASSERT_NO_MSG((sh->shell_flag == SHELL_FLAG_CRLF_DEFAULT) ||
+			(sh->shell_flag == SHELL_FLAG_OLF_CRLF));
 
-	memset(shell->ctx, 0, sizeof(*shell->ctx));
-	shell->ctx->prompt = shell->default_prompt;
+	memset(sh->ctx, 0, sizeof(*sh->ctx));
+	sh->ctx->prompt = sh->default_prompt;
 	if (CONFIG_SHELL_CMD_ROOT[0]) {
-		shell->ctx->selected_cmd = root_cmd_find(CONFIG_SHELL_CMD_ROOT);
+		sh->ctx->selected_cmd = root_cmd_find(CONFIG_SHELL_CMD_ROOT);
 	}
 
-	history_init(shell);
+	history_init(sh);
 
-	k_mutex_init(&shell->ctx->wr_mtx);
+	k_mutex_init(&sh->ctx->wr_mtx);
 
 	for (int i = 0; i < SHELL_SIGNALS; i++) {
-		k_poll_signal_init(&shell->ctx->signals[i]);
-		k_poll_event_init(&shell->ctx->events[i],
+		k_poll_signal_init(&sh->ctx->signals[i]);
+		k_poll_event_init(&sh->ctx->events[i],
 				  K_POLL_TYPE_SIGNAL,
 				  K_POLL_MODE_NOTIFY_ONLY,
-				  &shell->ctx->signals[i]);
+				  &sh->ctx->signals[i]);
 	}
 
 	if (IS_ENABLED(CONFIG_SHELL_STATS)) {
-		shell->stats->log_lost_cnt = 0;
+		sh->stats->log_lost_cnt = 0;
 	}
 
-	z_flag_tx_rdy_set(shell, true);
-	z_flag_echo_set(shell, IS_ENABLED(CONFIG_SHELL_ECHO_STATUS));
-	z_flag_obscure_set(shell, IS_ENABLED(CONFIG_SHELL_START_OBSCURED));
-	z_flag_mode_delete_set(shell,
-			     IS_ENABLED(CONFIG_SHELL_BACKSPACE_MODE_DELETE));
-	shell->ctx->vt100_ctx.cons.terminal_wid =
-					CONFIG_SHELL_DEFAULT_TERMINAL_WIDTH;
-	shell->ctx->vt100_ctx.cons.terminal_hei =
-					CONFIG_SHELL_DEFAULT_TERMINAL_HEIGHT;
-	shell->ctx->vt100_ctx.cons.name_len = z_shell_strlen(shell->ctx->prompt);
-	z_flag_use_colors_set(shell, IS_ENABLED(CONFIG_SHELL_VT100_COLORS) && use_colors);
+	z_flag_tx_rdy_set(sh, true);
 
-	int ret = shell->iface->api->init(shell->iface, p_config,
-					  transport_evt_handler,
-					  (void *)shell);
+	sh->ctx->vt100_ctx.cons.terminal_wid =
+					CONFIG_SHELL_DEFAULT_TERMINAL_WIDTH;
+	sh->ctx->vt100_ctx.cons.terminal_hei =
+					CONFIG_SHELL_DEFAULT_TERMINAL_HEIGHT;
+	sh->ctx->vt100_ctx.cons.name_len = z_shell_strlen(sh->ctx->prompt);
+
+	/* Configure backend according to enabled shell features and backend
+	 * specific settings.
+	 */
+	cfg_flags.obscure     &= IS_ENABLED(CONFIG_SHELL_START_OBSCURED);
+	cfg_flags.use_colors  &= IS_ENABLED(CONFIG_SHELL_VT100_COLORS);
+	cfg_flags.use_vt100   &= IS_ENABLED(CONFIG_SHELL_VT100_COMMANDS);
+	cfg_flags.echo        &= IS_ENABLED(CONFIG_SHELL_ECHO_STATUS);
+	cfg_flags.mode_delete &= IS_ENABLED(CONFIG_SHELL_BACKSPACE_MODE_DELETE);
+	sh->ctx->cfg.flags = cfg_flags;
+
+	int ret = sh->iface->api->init(sh->iface, transport_config,
+				       transport_evt_handler,
+				       (void *)sh);
 	if (ret == 0) {
-		state_set(shell, SHELL_STATE_INITIALIZED);
+		state_set(sh, SHELL_STATE_INITIALIZED);
 	}
 
 	return ret;
@@ -1339,7 +1346,8 @@ void shell_thread(void *shell_handle, void *arg_log_backend,
 }
 
 int shell_init(const struct shell *shell, const void *transport_config,
-	       bool use_colors, bool log_backend, uint32_t init_log_level)
+	       struct shell_backend_config_flags cfg_flags,
+	       bool log_backend, uint32_t init_log_level)
 {
 	__ASSERT_NO_MSG(shell);
 	__ASSERT_NO_MSG(shell->ctx && shell->iface && shell->default_prompt);
@@ -1348,7 +1356,7 @@ int shell_init(const struct shell *shell, const void *transport_config,
 		return -EALREADY;
 	}
 
-	int err = instance_init(shell, transport_config, use_colors);
+	int err = instance_init(shell, transport_config, cfg_flags);
 
 	if (err != 0) {
 		return err;
@@ -1458,33 +1466,33 @@ void shell_process(const struct shell *shell)
 /* This function mustn't be used from shell context to avoid deadlock.
  * However it can be used in shell command handlers.
  */
-void shell_vfprintf(const struct shell *shell, enum shell_vt100_color color,
+void shell_vfprintf(const struct shell *sh, enum shell_vt100_color color,
 		   const char *fmt, va_list args)
 {
-	__ASSERT_NO_MSG(shell);
+	__ASSERT_NO_MSG(sh);
 	__ASSERT(!k_is_in_isr(), "Thread context required.");
-	__ASSERT_NO_MSG(shell->ctx);
-	__ASSERT_NO_MSG((shell->ctx->internal.flags.cmd_ctx == 1) ||
-			(k_current_get() != shell->ctx->tid));
-	__ASSERT_NO_MSG(shell->fprintf_ctx);
+	__ASSERT_NO_MSG(sh->ctx);
+	__ASSERT_NO_MSG(z_flag_cmd_ctx_get(sh) ||
+			(k_current_get() != sh->ctx->tid));
+	__ASSERT_NO_MSG(sh->fprintf_ctx);
 	__ASSERT_NO_MSG(fmt);
 
 	/* Sending a message to a non-active shell leads to a dead lock. */
-	if (state_get(shell) != SHELL_STATE_ACTIVE) {
-		z_flag_print_noinit_set(shell, true);
+	if (state_get(sh) != SHELL_STATE_ACTIVE) {
+		z_flag_print_noinit_set(sh, true);
 		return;
 	}
 
-	k_mutex_lock(&shell->ctx->wr_mtx, K_FOREVER);
-	if (!z_flag_cmd_ctx_get(shell) && !shell->ctx->bypass) {
-		z_shell_cmd_line_erase(shell);
+	k_mutex_lock(&sh->ctx->wr_mtx, K_FOREVER);
+	if (!z_flag_cmd_ctx_get(sh) && !sh->ctx->bypass) {
+		z_shell_cmd_line_erase(sh);
 	}
-	z_shell_vfprintf(shell, color, fmt, args);
-	if (!z_flag_cmd_ctx_get(shell) && !shell->ctx->bypass) {
-		z_shell_print_prompt_and_cmd(shell);
+	z_shell_vfprintf(sh, color, fmt, args);
+	if (!z_flag_cmd_ctx_get(sh) && !sh->ctx->bypass) {
+		z_shell_print_prompt_and_cmd(sh);
 	}
-	z_transport_buffer_flush(shell);
-	k_mutex_unlock(&shell->ctx->wr_mtx);
+	z_transport_buffer_flush(sh);
+	k_mutex_unlock(&sh->ctx->wr_mtx);
 }
 
 /* This function mustn't be used from shell context to avoid deadlock.
@@ -1575,7 +1583,7 @@ void shell_help(const struct shell *shell)
 	k_mutex_unlock(&shell->ctx->wr_mtx);
 }
 
-int shell_execute_cmd(const struct shell *shell, const char *cmd)
+int shell_execute_cmd(const struct shell *sh, const char *cmd)
 {
 	uint16_t cmd_len = z_shell_strlen(cmd);
 	int ret_val;
@@ -1588,27 +1596,26 @@ int shell_execute_cmd(const struct shell *shell, const char *cmd)
 		return -ENOMEM;
 	}
 
-	if (shell == NULL) {
+	if (sh == NULL) {
 #if defined(CONFIG_SHELL_BACKEND_DUMMY)
-		shell = shell_backend_dummy_get_ptr();
+		sh = shell_backend_dummy_get_ptr();
 #else
 		return -EINVAL;
 #endif
 	}
 
-	__ASSERT(shell->ctx->internal.flags.cmd_ctx == 0,
-						"Function cannot be called"
-						" from command context");
+	__ASSERT(!z_flag_cmd_ctx_get(sh), "Function cannot be called"
+					  " from command context");
 
-	strcpy(shell->ctx->cmd_buff, cmd);
-	shell->ctx->cmd_buff_len = cmd_len;
-	shell->ctx->cmd_buff_pos = cmd_len;
+	strcpy(sh->ctx->cmd_buff, cmd);
+	sh->ctx->cmd_buff_len = cmd_len;
+	sh->ctx->cmd_buff_pos = cmd_len;
 
-	k_mutex_lock(&shell->ctx->wr_mtx, K_FOREVER);
-	ret_val = execute(shell);
-	k_mutex_unlock(&shell->ctx->wr_mtx);
+	k_mutex_lock(&sh->ctx->wr_mtx, K_FOREVER);
+	ret_val = execute(sh);
+	k_mutex_unlock(&sh->ctx->wr_mtx);
 
-	cmd_buffer_clear(shell);
+	cmd_buffer_clear(sh);
 
 	return ret_val;
 }
diff --git a/subsys/shell/shell_dummy.c b/subsys/shell/shell_dummy.c
index 2ff824d5731..0142a159627 100644
--- a/subsys/shell/shell_dummy.c
+++ b/subsys/shell/shell_dummy.c
@@ -101,7 +101,9 @@ const struct shell_transport_api shell_dummy_transport_api = {
 static int enable_shell_dummy(const struct device *arg)
 {
 	ARG_UNUSED(arg);
-	shell_init(&shell_dummy, NULL, true, true, LOG_LEVEL_INF);
+	static const struct shell_backend_config_flags cfg_flags =
+					SHELL_DEFAULT_BACKEND_CONFIG_FLAGS;
+	shell_init(&shell_dummy, NULL, cfg_flags, true, LOG_LEVEL_INF);
 	return 0;
 }
 SYS_INIT(enable_shell_dummy, POST_KERNEL, 0);
diff --git a/subsys/shell/shell_ops.h b/subsys/shell/shell_ops.h
index 37b8131931f..e1d2ad1efc1 100644
--- a/subsys/shell/shell_ops.h
+++ b/subsys/shell/shell_ops.h
@@ -28,43 +28,16 @@ static inline void z_shell_raw_fprintf(const struct shell_fprintf *const ctx,
 /* Macro to send VT100 command. */
 #define Z_SHELL_VT100_CMD(_shell_, ...)					\
 	do {								\
-		if (!IS_ENABLED(CONFIG_SHELL_VT100_COMMANDS))		\
+		if (!IS_ENABLED(CONFIG_SHELL_VT100_COMMANDS) ||		\
+		    !z_flag_use_vt100_get(_shell_))			\
 			break;						\
 		z_shell_raw_fprintf(_shell_->fprintf_ctx, __VA_ARGS__);	\
 	} while (0)
 
-/* Function sends VT100 command to clear the screen from cursor position to
- * end of the screen.
- */
-static inline void z_clear_eos(const struct shell *shell)
-{
-	Z_SHELL_VT100_CMD(shell, SHELL_VT100_CLEAREOS);
-}
-
-/* Function sends VT100 command to save cursor position. */
-static inline void z_cursor_save(const struct shell *shell)
-{
-	Z_SHELL_VT100_CMD(shell, SHELL_VT100_SAVECURSOR);
-}
-
-/* Function sends VT100 command to restore saved cursor position. */
-static inline void z_cursor_restore(const struct shell *shell)
-{
-	Z_SHELL_VT100_CMD(shell, SHELL_VT100_RESTORECURSOR);
-}
-
-/* Function forcing new line - cannot be replaced with function
- * cursor_down_move.
- */
-static inline void z_cursor_next_line_move(const struct shell *shell)
-{
-	z_shell_raw_fprintf(shell->fprintf_ctx, "\n");
-}
-
-#define Z_SHELL_SET_FLAG_ATOMIC(_shell_, _flag_, _val_, _ret_)			\
+#define Z_SHELL_SET_FLAG_ATOMIC(_shell_, _type_, _flag_, _val_, _ret_)		\
 	do {									\
-		union shell_internal _internal_;				\
-		atomic_t *_dst_ = (atomic_t *)&(_shell_)->ctx->internal.value;	\
+		union shell_backend_##_type_ _internal_;			\
+		atomic_t *_dst_ = (atomic_t *)&(_shell_)->ctx->_type_.value;	\
 		_internal_.value = 0U;						\
 		_internal_.flags._flag_ = 1U;					\
 		if (_val_) {							\
@@ -77,166 +50,208 @@ static inline void z_cursor_next_line_move(const struct shell *shell)
 		_ret_ = (_internal_.flags._flag_ != 0);				\
 	} while (0)
 
-static inline bool z_flag_insert_mode_get(const struct shell *shell)
+static inline bool z_flag_insert_mode_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.insert_mode == 1;
+	return sh->ctx->cfg.flags.insert_mode == 1;
 }
 
-static inline bool z_flag_insert_mode_set(const struct shell *shell, bool val)
+static inline bool z_flag_insert_mode_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, insert_mode, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, cfg, insert_mode, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_use_colors_get(const struct shell *shell)
+static inline bool z_flag_use_colors_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.use_colors == 1;
+	return sh->ctx->cfg.flags.use_colors == 1;
 }
 
-static inline bool z_flag_use_colors_set(const struct shell *shell, bool val)
+static inline bool z_flag_use_colors_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, use_colors, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, cfg, use_colors, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_echo_get(const struct shell *shell)
+static inline bool z_flag_use_vt100_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.echo == 1;
+	return sh->ctx->cfg.flags.use_vt100 == 1;
 }
 
-static inline bool z_flag_echo_set(const struct shell *shell, bool val)
+static inline bool z_flag_use_vt100_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, echo, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, cfg, use_vt100, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_obscure_get(const struct shell *shell)
+static inline bool z_flag_echo_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.obscure == 1;
+	return sh->ctx->cfg.flags.echo == 1;
 }
 
-static inline bool z_flag_obscure_set(const struct shell *shell, bool val)
+static inline bool z_flag_echo_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, obscure, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, cfg, echo, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_processing_get(const struct shell *shell)
+static inline bool z_flag_obscure_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.processing == 1;
+	return sh->ctx->cfg.flags.obscure == 1;
 }
 
-static inline bool z_flag_processing_set(const struct shell *shell, bool val)
+static inline bool z_flag_obscure_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, processing, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, cfg, obscure, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_tx_rdy_get(const struct shell *shell)
+static inline bool z_flag_processing_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.tx_rdy == 1;
+	return sh->ctx->ctx.flags.processing == 1;
 }
 
-static inline bool z_flag_tx_rdy_set(const struct shell *shell, bool val)
+static inline bool z_flag_processing_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, tx_rdy, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, ctx, processing, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_mode_delete_get(const struct shell *shell)
+static inline bool z_flag_tx_rdy_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.mode_delete == 1;
+	return sh->ctx->ctx.flags.tx_rdy == 1;
 }
 
-static inline bool z_flag_mode_delete_set(const struct shell *shell, bool val)
+static inline bool z_flag_tx_rdy_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, mode_delete, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, ctx, tx_rdy, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_history_exit_get(const struct shell *shell)
+static inline bool z_flag_mode_delete_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.history_exit == 1;
+	return sh->ctx->cfg.flags.mode_delete == 1;
 }
 
-static inline bool z_flag_history_exit_set(const struct shell *shell, bool val)
+static inline bool z_flag_mode_delete_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, history_exit, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, cfg, mode_delete, val, ret);
 	return ret;
 }
 
-static inline bool z_flag_cmd_ctx_get(const struct shell *shell)
+static inline bool z_flag_history_exit_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.cmd_ctx == 1;
+	return sh->ctx->ctx.flags.history_exit == 1;
 }
 
-static inline bool z_flag_cmd_ctx_set(const struct shell *shell, bool val)
+static inline bool z_flag_history_exit_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, cmd_ctx, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, ctx, history_exit, val, ret);
 	return ret;
 }
 
-static inline uint8_t z_flag_last_nl_get(const struct shell *shell)
+static inline bool z_flag_cmd_ctx_get(const struct shell *sh)
 {
-	return shell->ctx->internal.flags.last_nl;
+	return sh->ctx->ctx.flags.cmd_ctx == 1;
 }
 
-static inline void z_flag_last_nl_set(const struct shell *shell, uint8_t val)
-{
-	shell->ctx->internal.flags.last_nl = val;
-}
-
-static inline bool z_flag_print_noinit_get(const struct shell *shell)
-{
-	return shell->ctx->internal.flags.print_noinit == 1;
-}
-
-static inline bool z_flag_print_noinit_set(const struct shell *shell, bool val)
+static inline bool z_flag_cmd_ctx_set(const struct shell *sh, bool val)
 {
 	bool ret;
 
-	Z_SHELL_SET_FLAG_ATOMIC(shell, print_noinit, val, ret);
+	Z_SHELL_SET_FLAG_ATOMIC(sh, ctx, cmd_ctx, val, ret);
 	return ret;
 }
 
-void z_shell_op_cursor_vert_move(const struct shell *shell, int32_t delta);
-void z_shell_op_cursor_horiz_move(const struct shell *shell, int32_t delta);
+static inline uint8_t z_flag_last_nl_get(const struct shell *sh)
+{
+	return sh->ctx->ctx.flags.last_nl;
+}
 
-void z_shell_op_cond_next_line(const struct shell *shell);
+static inline void z_flag_last_nl_set(const struct shell *sh, uint8_t val)
+{
+	sh->ctx->ctx.flags.last_nl = val;
+}
+
+static inline bool z_flag_print_noinit_get(const struct shell *sh)
+{
+	return sh->ctx->ctx.flags.print_noinit == 1;
+}
+
+static inline bool z_flag_print_noinit_set(const struct shell *sh, bool val)
+{
+	bool ret;
+
+	Z_SHELL_SET_FLAG_ATOMIC(sh, ctx, print_noinit, val, ret);
+	return ret;
+}
+
+/* Function sends VT100 command to clear the screen from cursor position to
+ * end of the screen.
+ */
+static inline void z_clear_eos(const struct shell *sh)
+{
+	Z_SHELL_VT100_CMD(sh, SHELL_VT100_CLEAREOS);
+}
+
+/* Function sends VT100 command to save cursor position. */
+static inline void z_cursor_save(const struct shell *sh)
+{
+	Z_SHELL_VT100_CMD(sh, SHELL_VT100_SAVECURSOR);
+}
+
+/* Function sends VT100 command to restore saved cursor position. */
+static inline void z_cursor_restore(const struct shell *sh)
+{
+	Z_SHELL_VT100_CMD(sh, SHELL_VT100_RESTORECURSOR);
+}
+
+/* Function forcing new line - cannot be replaced with function
+ * cursor_down_move.
+ */
+static inline void z_cursor_next_line_move(const struct shell *sh)
+{
+	z_shell_raw_fprintf(sh->fprintf_ctx, "\n");
+}
+
+void z_shell_op_cursor_vert_move(const struct shell *sh, int32_t delta);
+
+void z_shell_op_cursor_horiz_move(const struct shell *sh, int32_t delta);
+
+void z_shell_op_cond_next_line(const struct shell *sh);
 
 /* Function will move cursor back to position == cmd_buff_pos. Example usage is
  * when cursor needs to be moved back after printing some text. This function
  * cannot be used to move cursor to new location by manual change of
  * cmd_buff_pos.
  */
-void z_shell_op_cursor_position_synchronize(const struct shell *shell);
+void z_shell_op_cursor_position_synchronize(const struct shell *sh);
 
-void z_shell_op_cursor_move(const struct shell *shell, int16_t val);
+void z_shell_op_cursor_move(const struct shell *sh, int16_t val);
 
-void z_shell_op_left_arrow(const struct shell *shell);
+void z_shell_op_left_arrow(const struct shell *sh);
 
-void z_shell_op_right_arrow(const struct shell *shell);
+void z_shell_op_right_arrow(const struct shell *sh);
 
 /* Moves cursor by defined number of words left (val negative) or right. */
-void z_shell_op_cursor_word_move(const struct shell *shell, int16_t val);
+void z_shell_op_cursor_word_move(const struct shell *sh, int16_t val);
 
 /*
  *  Removes the "word" to the left of the cursor:
@@ -244,45 +259,45 @@ void z_shell_op_cursor_word_move(const struct shell *shell, int16_t val);
  *  - remove the non-spaces (word) until a space is found or a beginning of
  *    buffer
  */
-void z_shell_op_word_remove(const struct shell *shell);
+void z_shell_op_word_remove(const struct shell *sh);
 
 /* Function moves cursor to begin of command position, just after console
  * name.
  */
-void z_shell_op_cursor_home_move(const struct shell *shell);
+void z_shell_op_cursor_home_move(const struct shell *sh);
 
 /* Function moves cursor to end of command. */
-void z_shell_op_cursor_end_move(const struct shell *shell);
+void z_shell_op_cursor_end_move(const struct shell *sh);
 
-void z_shell_op_char_insert(const struct shell *shell, char data);
+void z_shell_op_char_insert(const struct shell *sh, char data);
 
-void z_shell_op_char_backspace(const struct shell *shell);
+void z_shell_op_char_backspace(const struct shell *sh);
 
-void z_shell_op_char_delete(const struct shell *shell);
+void z_shell_op_char_delete(const struct shell *sh);
 
-void z_shell_op_delete_from_cursor(const struct shell *shell);
+void z_shell_op_delete_from_cursor(const struct shell *sh);
 
-void z_shell_op_completion_insert(const struct shell *shell,
+void z_shell_op_completion_insert(const struct shell *sh,
 				  const char *compl,
 				  uint16_t compl_len);
 
-bool z_shell_cursor_in_empty_line(const struct shell *shell);
+bool z_shell_cursor_in_empty_line(const struct shell *sh);
 
-void z_shell_cmd_line_erase(const struct shell *shell);
+void z_shell_cmd_line_erase(const struct shell *sh);
 
 /**
  * @brief Print command buffer.
  *
  * @param shell Shell instance.
  */
-void z_shell_print_cmd(const struct shell *shell);
+void z_shell_print_cmd(const struct shell *sh);
 
 /**
  * @brief Print prompt followed by command buffer.
  *
  * @param shell Shell instance.
  */
-void z_shell_print_prompt_and_cmd(const struct shell *shell);
+void z_shell_print_prompt_and_cmd(const struct shell *sh);
 
 /* Function sends data stream to the shell instance. Each time before the
  * shell_write function is called, it must be ensured that IO buffer of fprintf
@@ -292,7 +307,7 @@ void z_shell_print_prompt_and_cmd(const struct shell *shell);
  * This function can be only used by shell module, it shall not be called
  * directly.
  */
-void z_shell_write(const struct shell *shell, const void *data, size_t length);
+void z_shell_write(const struct shell *sh, const void *data, size_t length);
 
 /**
  * @internal @brief This function shall not be used directly, it is required by
@@ -305,25 +320,25 @@ void z_shell_write(const struct shell *shell, const void *data, size_t length);
 void z_shell_print_stream(const void *user_ctx, const char *data, size_t len);
 
 /** @internal @brief Function for setting font color */
-void z_shell_vt100_color_set(const struct shell *shell,
+void z_shell_vt100_color_set(const struct shell *sh,
 			     enum shell_vt100_color color);
 
-static inline void z_shell_vt100_colors_store(const struct shell *shell,
+static inline void z_shell_vt100_colors_store(const struct shell *sh,
 					      struct shell_vt100_colors *color)
 {
-	memcpy(color, &shell->ctx->vt100_ctx.col, sizeof(*color));
+	memcpy(color, &sh->ctx->vt100_ctx.col, sizeof(*color));
 }
 
-void z_shell_vt100_colors_restore(const struct shell *shell,
+void z_shell_vt100_colors_restore(const struct shell *sh,
 				  const struct shell_vt100_colors *color);
 
 /* This function can be called only within shell thread but not from command
  * handlers.
  */
-void z_shell_fprintf(const struct shell *shell, enum shell_vt100_color color,
+void z_shell_fprintf(const struct shell *sh, enum shell_vt100_color color,
 		     const char *fmt, ...);
 
-void z_shell_vfprintf(const struct shell *shell, enum shell_vt100_color color,
+void z_shell_vfprintf(const struct shell *sh, enum shell_vt100_color color,
 		      const char *fmt, va_list args);
 
 #ifdef __cplusplus
diff --git a/subsys/shell/shell_rtt.c b/subsys/shell/shell_rtt.c
index 1480a3690c9..7283d4a60b1 100644
--- a/subsys/shell/shell_rtt.c
+++ b/subsys/shell/shell_rtt.c
@@ -113,8 +113,10 @@ static int enable_shell_rtt(const struct device *arg)
 	bool log_backend = CONFIG_SHELL_RTT_INIT_LOG_LEVEL > 0;
 	uint32_t level = (CONFIG_SHELL_RTT_INIT_LOG_LEVEL > LOG_LEVEL_DBG) ?
 		      CONFIG_LOG_MAX_LEVEL : CONFIG_SHELL_RTT_INIT_LOG_LEVEL;
+	static const struct shell_backend_config_flags cfg_flags =
+					SHELL_DEFAULT_BACKEND_CONFIG_FLAGS;
 
-	shell_init(&shell_rtt, NULL, true, log_backend, level);
+	shell_init(&shell_rtt, NULL, cfg_flags, log_backend, level);
 
 	return 0;
 }
diff --git a/subsys/shell/shell_telnet.c b/subsys/shell/shell_telnet.c
index c13c51377ad..94d74cc6393 100644
--- a/subsys/shell/shell_telnet.c
+++ b/subsys/shell/shell_telnet.c
@@ -495,8 +495,10 @@ static int enable_shell_telnet(const struct device *arg)
 	bool log_backend = CONFIG_SHELL_TELNET_INIT_LOG_LEVEL > 0;
 	uint32_t level = (CONFIG_SHELL_TELNET_INIT_LOG_LEVEL > LOG_LEVEL_DBG) ?
 		      CONFIG_LOG_MAX_LEVEL : CONFIG_SHELL_TELNET_INIT_LOG_LEVEL;
+	static const struct shell_backend_config_flags cfg_flags =
+					SHELL_DEFAULT_BACKEND_CONFIG_FLAGS;
 
-	return shell_init(&shell_telnet, NULL, true, log_backend, level);
+	return shell_init(&shell_telnet, NULL, cfg_flags, log_backend, level);
 }
 
 SYS_INIT(enable_shell_telnet, APPLICATION, 0);
diff --git a/subsys/shell/shell_uart.c b/subsys/shell/shell_uart.c
index 64b53e29fc7..18f26db7638 100644
--- a/subsys/shell/shell_uart.c
+++ b/subsys/shell/shell_uart.c
@@ -319,6 +319,8 @@ static int enable_shell_uart(const struct device *arg)
 	uint32_t level =
 		(CONFIG_SHELL_BACKEND_SERIAL_LOG_LEVEL > LOG_LEVEL_DBG) ?
 		CONFIG_LOG_MAX_LEVEL : CONFIG_SHELL_BACKEND_SERIAL_LOG_LEVEL;
+	static const struct shell_backend_config_flags cfg_flags =
+					SHELL_DEFAULT_BACKEND_CONFIG_FLAGS;
 
 	if (!device_is_ready(dev)) {
 		return -ENODEV;
@@ -328,10 +330,11 @@ static int enable_shell_uart(const struct device *arg)
 		smp_shell_init();
 	}
 
-	shell_init(&shell_uart, dev, true, log_backend, level);
+	shell_init(&shell_uart, dev, cfg_flags, log_backend, level);
 
 	return 0;
 }
+
 SYS_INIT(enable_shell_uart, POST_KERNEL,
 	 CONFIG_SHELL_BACKEND_SERIAL_INIT_PRIORITY);