diff --git a/dev-environment.yml b/dev-environment.yml
index 2547bde..582813c 100644
--- a/dev-environment.yml
+++ b/dev-environment.yml
@@ -5,7 +5,6 @@ dependencies:
     - pip
     - jupyter_server
     - jupyterlab_server
-    - jupyterlite-core >=0.3,<0.6
     - jupytext
     - pydata-sphinx-theme
     - micromamba=2.0.5
@@ -16,4 +15,5 @@ dependencies:
     - voici
     - pip:
         - .
-        - jupyterlite-xeus >=2.1.2
+        - jupyterlite-core ==0.6.0a9
+        # - jupyterlite-xeus >=2.1.2
diff --git a/docs/configuration.md b/docs/configuration.md
index 3774fb9..10221c8 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -85,11 +85,50 @@ voici_new_tab_button_text = "My custom Voici button text"
 You can override this text on a per-directive basis by passing the `:new_tab_button_text:` option
 to the directive. Note that this is compatible only if `:new_tab:` is also provided.
 
-## REPL code auto-execution with the `Replite` directive
+## REPL configuration options
 
-It is possible to control whether code snippets in REPL environments automatically executes when loaded.
-For this, you may set `replite_auto_execute = False` globally in `conf.py` with  (defaults to `True` if
-not present), or override it on a per-directive basis  with `:execute: True` or `:execute: False`.
+We provide several configuration options for the Replite directive that control the behaviour and appearance of the REPL. These options can be set globally in `conf.py` and then overridden on a per-directive basis.
+
+### REPL code auto-execution
+
+```python
+# enable or disable automatic code execution when the REPL loads
+# (available in jupyterlite-core 0.5.0 and later)
+replite_auto_execute = True  # default is True
+```
+
+This setting controls whether code snippets in REPL environments automatically execute when loaded. Set to `False` to disable automatic execution. You can override this on a per-directive basis with `:execute: True` or `:execute: False`.
+
+### REPL interface customisations (JupyterLite 0.6.0 and later)
+
+The following options customise how the REPL interface behaves and is presented:
+
+```python
+# clear previous cells when a new cell is executed
+replite_clear_cells_on_execute = False  # default is False
+
+# clear the code content in the prompt cell after execution
+replite_clear_code_content_on_execute = False  # default is False
+
+# hide input cells, showing only output
+replite_hide_code_input = False  # default is False
+
+# position of the prompt cell ('bottom', 'top', 'left', or 'right')
+replite_prompt_cell_position = "bottom"  # default is "bottom"
+
+# show or hide the kernel banner
+replite_show_banner = True  # default is True
+```
+
+These global settings can be overridden in individual directives using the corresponding options:
+
+- `:clear_cells_on_execute: True/False`
+- `:clear_code_content_on_execute: True/False`
+- `:hide_code_input: True/False`
+- `:prompt_cell_position: bottom/top/left/right`
+- `:show_banner: True/False`
+
+For more details and visual examples of each, see the [Replite directive documentation](directives/replite.md).
 
 ## Strip particular tagged cells from IPython Notebooks
 
@@ -120,7 +159,7 @@ Sphinx-specific content. It can be used to remove either code cells or Markdown
 For example, you can use this feature to remove the `toctree` directive from the rendered notebook
 in the JupyterLite console:
 
-```json
+````json
 {
   "cells": [
     {
@@ -148,7 +187,7 @@ in the JupyterLite console:
     }
   ]
 }
-```
+````
 
 where the cell with the `toctree` directive will be removed from the rendered notebook in
 the JupyterLite console.
diff --git a/docs/directives/replite.md b/docs/directives/replite.md
index 26f115f..33015ed 100644
--- a/docs/directives/replite.md
+++ b/docs/directives/replite.md
@@ -157,3 +157,173 @@ global value using an additional `:new_tab_button_text:` parameter:
 ```
 
 ````
+
+````{tip}
+
+   ## Additional REPL interface options (JupyterLite 0.6.0+)
+
+   With `jupyterlite-core` versions 0.6.0 and later, the REPL interface comes with several additional customisation options that provide more control over the execution environment and layout:
+
+   ### Clearing cells on execute
+
+   To automatically clear the previously executed cells when a new cell is executed, use the `:clear_cells_on_execute:` option:
+
+   ```rst
+   .. replite::
+      :kernel: xeus-python
+      :clear_cells_on_execute: True
+
+      # When you execute this cell and then enter new code,
+      # this cell will disappear from the display
+      print("Hello, world!")
+   ```
+
+   ```{eval-rst}
+   .. replite::
+      :kernel: xeus-python
+      :clear_cells_on_execute: True
+
+      # When you execute this cell and then enter new code,
+      # this cell will disappear from the display
+      print("Hello, world!")
+   ```
+
+   ### Clearing code content on execute
+
+   To automatically clear the code content in the prompt cell after execution, use the `:clear_code_on_execute:` option:
+
+   ```rst
+   .. replite::
+      :kernel: xeus-python
+      :clear_code_content_on_execute: True
+
+      # After executing this cell, its content will be cleared,
+      # but the output will remain visible
+      print("The code will disappear but this output stays")
+   ```
+
+   ```{eval-rst}
+   .. replite::
+      :kernel: xeus-python
+      :clear_code_content_on_execute: True
+
+      # After executing this cell, its content will be cleared,
+      # but the output will remain visible
+      print("The code will disappear but this output stays")
+   ```
+
+   ### Hiding code input
+
+   To hide the input cells after execution, showing only the output, use the `:hide_code_input:` option:
+
+   ```rst
+   .. replite::
+      :kernel: xeus-python
+      :hide_code_input: True
+
+      # After executing this cell, the input will be hidden,
+      # but the output will remain visible
+      print("You'll see this output but not the code that generated it")
+   ```
+
+   ```{eval-rst}
+   .. replite::
+      :kernel: xeus-python
+      :hide_code_input: True
+
+      # After execution, this code will be hidden
+      # Only the output will be visible
+      print("You'll see this output but not the code that generated it")
+   ```
+
+   ### Changing prompt cell position
+
+   By default, the prompt cell is positioned at the bottom of the REPL interface. You can change this using the `:prompt_cell_position:` option, which accepts `top`, `bottom`, `left`, or `right`:
+
+   ```rst
+   .. replite::
+      :kernel: xeus-python
+      :prompt_cell_position: top
+
+      # The prompt will appear at the top of the REPL
+      print("Input above, output below")
+   ```
+
+   ```{eval-rst}
+   .. replite::
+      :kernel: xeus-python
+      :prompt_cell_position: top
+
+      # The prompt will appear at the top of the REPL
+      print("Input above, output below")
+   ```
+
+   ### Showing or hiding the kernel banner
+
+   By default, the REPL shows the kernel banner with version information. To hide this banner, use the `:show_banner:` option:
+
+   ```rst
+   .. replite::
+      :kernel: xeus-python
+      :show_banner: False
+
+      # The kernel banner won't be displayed
+      print("No banner here")
+   ```
+
+   ```{eval-rst}
+   .. replite::
+      :kernel: xeus-python
+      :show_banner: False
+
+      # The kernel banner won't be displayed
+      print("No banner here")
+   ```
+
+   ### Combining options
+   All of these options can be combined to create a customised REPL experience,
+   for example:
+
+   ```rst
+   .. replite::
+      :kernel: xeus-python
+      :prompt_cell_position: left
+      :hide_code_input: True
+      :show_banner: False
+      :height: 400px
+
+      # This will create a clean output-only display
+      # with the input cell on the left
+      import matplotlib.pyplot as plt
+      import numpy as np
+
+      x = np.linspace(0, 2 * np.pi, 200)
+      y = np.sin(x)
+
+      fig, ax = plt.subplots()
+      ax.plot(x, y)
+      plt.show()
+   ```
+
+   ```{eval-rst}
+   .. replite::
+      :kernel: xeus-python
+      :prompt_cell_position: left
+      :hide_code_input: True
+      :show_banner: False
+      :height: 400px
+
+      # This will create a clean output-only display
+      # with the input cell on the left
+      import matplotlib.pyplot as plt
+      import numpy as np
+
+      x = np.linspace(0, 2 * np.pi, 200)
+      y = np.sin(x)
+
+      fig, ax = plt.subplots()
+      ax.plot(x, y)
+      plt.show()
+   ```
+
+````
diff --git a/jupyterlite_sphinx/jupyterlite_sphinx.py b/jupyterlite_sphinx/jupyterlite_sphinx.py
index 989a739..98a35b2 100644
--- a/jupyterlite_sphinx/jupyterlite_sphinx.py
+++ b/jupyterlite_sphinx/jupyterlite_sphinx.py
@@ -85,7 +85,7 @@ def html(self):
             )
 
             placeholder_id = uuid4()
-            container_style = f'width: {self["width"]}; height: {self["height"]};'
+            container_style = f"width: {self['width']}; height: {self['height']};"
 
             return f"""
                 <div
@@ -132,7 +132,7 @@ def __init__(
             [f"{key}={quote(value)}" for key, value in lite_options.items()]
         )
         self.lab_src = (
-            f'{prefix}/{app_path}{f"index.html?{options}" if options else ""}'
+            f"{prefix}/{app_path}{f'index.html?{options}' if options else ''}"
         )
 
         self.button_text = button_text
@@ -176,7 +176,7 @@ def __init__(
             [f"{key}={quote(value)}" for key, value in lite_options.items()]
         )
 
-        iframe_src = f'{prefix}/{app_path}{f"index.html?{options}" if options else ""}'
+        iframe_src = f"{prefix}/{app_path}{f'index.html?{options}' if options else ''}"
 
         if "iframe_src" in attributes:
             if attributes["iframe_src"] != iframe_src:
@@ -269,8 +269,27 @@ def __init__(
             code = "\n".join(code_lines)
             lite_options["code"] = code
 
+        # REPL URL parameters
         if "execute" in lite_options and lite_options["execute"] == "0":
             lite_options["execute"] = "0"
+        if (
+            "clearCellsOnExecute" in lite_options
+            and lite_options["clearCellsOnExecute"] == "0"
+        ):
+            lite_options["clearCellsOnExecute"] = "0"
+        if (
+            "clearCodeContentOnExecute" in lite_options
+            and lite_options["clearCodeContentOnExecute"] == "0"
+        ):
+            lite_options["clearCodeContentOnExecute"] = "0"
+        if "hideCodeInput" in lite_options and lite_options["hideCodeInput"] == "0":
+            lite_options["hideCodeInput"] = "0"
+        if "showBanner" in lite_options and lite_options["showBanner"] == "0":
+            lite_options["showBanner"] = "0"
+        if "promptCellPosition" in lite_options:
+            valid_positions = {"bottom", "top", "left", "right"}
+            if lite_options["promptCellPosition"] in valid_positions:
+                lite_options["promptCellPosition"] = lite_options["promptCellPosition"]
 
         app_path = self.lite_app
         if notebook is not None:
@@ -282,7 +301,7 @@ def __init__(
         )
 
         self.lab_src = (
-            f'{prefix}/{app_path}{f"index.html?{options}" if options else ""}'
+            f"{prefix}/{app_path}{f'index.html?{options}' if options else ''}"
         )
 
         self.button_text = button_text
@@ -346,7 +365,7 @@ def __init__(
         )
 
         # If a notebook is provided, open it in the render view. Else, we default to the tree view.
-        iframe_src = f'{prefix}/{app_path}{f"index.html?{options}" if options else ""}'
+        iframe_src = f"{prefix}/{app_path}{f'index.html?{options}' if options else ''}"
 
         super().__init__(rawsource, *children, iframe_src=iframe_src, **attributes)
 
@@ -366,7 +385,6 @@ def __init__(
         button_text=None,
         **attributes,
     ):
-
         self.lab_src = f"{prefix}/"
 
         app_path = VoiciBase.get_full_path(notebook)
@@ -375,7 +393,7 @@ def __init__(
         )
 
         # If a notebook is provided, open it in a new tab. Else, we default to the tree view.
-        self.lab_src = f'{prefix}/{app_path}{f"?{options}" if options else ""}'
+        self.lab_src = f"{prefix}/{app_path}{f'?{options}' if options else ''}"
 
         self.button_text = button_text
 
@@ -405,6 +423,11 @@ class RepliteDirective(SphinxDirective):
         "height": directives.unchanged,
         "kernel": directives.unchanged,
         "execute": directives.unchanged,
+        "clear_cells_on_execute": directives.unchanged,
+        "clear_code_content_on_execute": directives.unchanged,
+        "hide_code_input": directives.unchanged,
+        "prompt_cell_position": directives.unchanged,
+        "show_banner": directives.unchanged,
         "toolbar": directives.unchanged,
         "theme": directives.unchanged,
         "prompt": directives.unchanged,
@@ -424,14 +447,69 @@ def run(self):
         search_params = search_params_parser(self.options.pop("search_params", False))
 
         # We first check the global config, and then the per-directive
-        # option. It defaults to True for backwards compatibility.
-        execute = self.options.pop("execute", str(self.env.config.replite_auto_execute))
-
-        if execute not in ("True", "False"):
-            raise ValueError("The :execute: option must be either True or False")
-
-        if execute == "False":
-            self.options["execute"] = "0"
+        # options, with reasonable defaults for backwards compatibility.
+        repl_config_mappings = {
+            "execute": "execute",
+            "clear_cells_on_execute": "clearCellsOnExecute",
+            "clear_code_content_on_execute": "clearCodeContentOnExecute",
+            "hide_code_input": "hideCodeInput",
+            "show_banner": "showBanner",
+            "prompt_cell_position": "promptCellPosition",
+        }
+
+        for option in repl_config_mappings:
+            config_option = repl_config_mappings[option]
+            if option == "execute":
+                value = self.options.pop(
+                    option, str(self.env.config.replite_auto_execute)
+                )
+            elif option == "clear_cells_on_execute":
+                value = self.options.pop(
+                    option, str(self.env.config.replite_clear_cells_on_execute)
+                )
+            elif option == "clear_code_content_on_execute":
+                value = self.options.pop(
+                    option, str(self.env.config.replite_clear_code_content_on_execute)
+                )
+            elif option == "hide_code_input":
+                value = self.options.pop(
+                    option, str(self.env.config.replite_hide_code_input)
+                )
+            elif option == "show_banner":
+                value = self.options.pop(
+                    option, str(self.env.config.replite_show_banner)
+                )
+            elif option == "prompt_cell_position":
+                value = self.options.pop(
+                    option, str(self.env.config.replite_prompt_cell_position)
+                )
+            else:
+                err_msg = (
+                    f"Unknown option {option} for Replite directive. "
+                    "Please check the documentation for valid options."
+                )
+                raise ValueError(err_msg)
+
+            # Convert to URL parameter format (0/1) for all options
+            # except for prompt_cell_position
+            if option != "prompt_cell_position":
+                if value.lower() == "true":
+                    self.options[config_option] = "1"
+                elif value.lower() == "false":
+                    self.options[config_option] = "0"
+                else:
+                    err_msg = (
+                        f"The {option} option must be either True or False, not {value}"
+                    )
+                    raise ValueError(err_msg)
+            else:
+                # For prompt_cell_position, we need to check if the value is valid
+                if value not in ["top", "bottom", "left", "right"]:
+                    err_msg = (
+                        f"The {option} option must be one of: top, bottom, left, right"
+                    )
+                    raise ValueError(err_msg)
+                self.options[config_option] = value
 
         content = self.content
 
@@ -516,7 +594,6 @@ def _assert_no_conflicting_nb_names(
         # We do this to prevent conflicts with other files, say, in the "_contents/"
         # directory as a result of a previous failed/interrupted build.
         if source_path.parent != notebooks_dir:
-
             # We only consider conflicts if notebooks are actually referenced in
             # a directive, to prevent false posiitves from being raised.
             if hasattr(self.env, "jupyterlite_notebooks"):
@@ -526,7 +603,6 @@ def _assert_no_conflicting_nb_names(
                         existing_path.stem == target_stem
                         and existing_path != source_path
                     ):
-
                         raise RuntimeError(
                             "All notebooks marked for inclusion with JupyterLite must have a "
                             f"unique file basename. Found conflict between {source_path} and {existing_path}."
@@ -838,7 +914,7 @@ def run(self):
 
         iframe_parent_div_id = uuid4()
         iframe_div_id = uuid4()
-        iframe_src = f'{prefix}/{app_path}{f"index.html?{options}" if options else ""}'
+        iframe_src = f"{prefix}/{app_path}{f'index.html?{options}' if options else ''}"
 
         # Parent container (initially hidden)
         iframe_parent_container_div_start = (
@@ -1137,6 +1213,14 @@ def setup(app):
         "replite_new_tab_button_text", "Open in a REPL", rebuild="html"
     )
 
+    # REPL configuration options
+    app.add_config_value("replite_auto_execute", True, rebuild="html")
+    app.add_config_value("replite_clear_cells_on_execute", False, rebuild="html")
+    app.add_config_value("replite_clear_code_content_on_execute", False, rebuild="html")
+    app.add_config_value("replite_hide_code_input", False, rebuild="html")
+    app.add_config_value("replite_prompt_cell_position", "bottom", rebuild="html")
+    app.add_config_value("replite_show_banner", True, rebuild="html")
+
     # Initialize NotebookLite and JupyterLite directives
     app.add_node(
         NotebookLiteIframe,
@@ -1186,7 +1270,6 @@ def setup(app):
         man=(skip, None),
     )
     app.add_directive("replite", RepliteDirective)
-    app.add_config_value("replite_auto_execute", True, rebuild="html")
 
     # Initialize Voici directive and tabbed interface
     app.add_node(
diff --git a/pyproject.toml b/pyproject.toml
index 4473438..10a8f05 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,7 +16,7 @@ dependencies = [
     "docutils",
     "jupyter_server",
     "jupyterlab_server",
-    "jupyterlite-core >=0.2,<0.6",
+    "jupyterlite-core==0.6.0a9",
     "jupytext",
     "nbformat",
     "sphinx>=4",
@@ -30,7 +30,7 @@ dev = [
 docs = [
     "myst_parser",
     "pydata-sphinx-theme",
-    "jupyterlite-xeus>=0.1.8,<4",
+    # "jupyterlite-xeus>=0.1.8,<4",
 ]
 
 [tool.hatch.version]