diff --git a/packages/voila/src/plugins/widget/index.ts b/packages/voila/src/plugins/widget/index.ts
index 23e090e5c..505ad8f3c 100644
--- a/packages/voila/src/plugins/widget/index.ts
+++ b/packages/voila/src/plugins/widget/index.ts
@@ -34,6 +34,11 @@ import { VoilaApp } from '../../app';
 
 import { Widget } from '@lumino/widgets';
 import { RenderedCells } from './renderedcells';
+import {
+  // OutputArea,
+  OutputAreaModel,
+  SimplifiedOutputArea
+} from '@jupyterlab/outputarea';
 
 const WIDGET_MIMETYPE = 'application/vnd.jupyter.widget-view+json';
 
@@ -123,40 +128,107 @@ export const renderOutputsPlugin: JupyterFrontEndPlugin<void> = {
       rendermime.latexTypesetter?.typeset(md as HTMLElement);
     });
     // Render code cell
-    const cellOutputs = document.body.querySelectorAll(
-      'script[type="application/vnd.voila.cell-output+json"]'
-    );
-    cellOutputs.forEach(async (cellOutput) => {
-      const model = JSON.parse(cellOutput.innerHTML);
-
-      const mimeType = rendermime.preferredMimeType(model.data, 'any');
-
-      if (!mimeType) {
-        return null;
+    // const cellOutputs = document.body.querySelectorAll(
+    //   'script[type="application/vnd.voila.cell-output+json"]'
+    // );
+    // cellOutputs.forEach(async (cellOutput) => {
+    //   const model = JSON.parse(cellOutput.innerHTML);
+
+    //   const mimeType = rendermime.preferredMimeType(model.data, 'any');
+
+    //   if (!mimeType) {
+    //     return null;
+    //   }
+    //   const output = rendermime.createRenderer(mimeType);
+    //   output.renderModel(model).catch((error) => {
+    //     // Manually append error message to output
+    //     const pre = document.createElement('pre');
+    //     pre.textContent = `Javascript Error: ${error.message}`;
+    //     output.node.appendChild(pre);
+
+    //     // Remove mime-type-specific CSS classes
+    //     pre.className = 'lm-Widget jp-RenderedText';
+    //     pre.setAttribute('data-mime-type', 'application/vnd.jupyter.stderr');
+    //   });
+
+    //   output.addClass('jp-OutputArea-output');
+
+    //   if (cellOutput.parentElement) {
+    //     const container = cellOutput.parentElement;
+
+    //     container.removeChild(cellOutput);
+
+    //     // Attach output
+    //     Widget.attach(output, container);
+    //   }
+    // });
+    const kernelId = (app as VoilaApp).widgetManager?.kernel.id;
+    console.log('using kernel', kernelId);
+    const ws = new WebSocket(`ws://localhost:8866/voila/execution/${kernelId}`);
+    ws.onmessage = (msg) => {
+      const { action, payload } = JSON.parse(msg.data);
+      if (action === 'execution_result') {
+        const { cell_index, output_cell, request_kernel_id } = payload;
+        const element = document.querySelector(
+          `[cell-index="${cell_index + 1}"]`
+        );
+        if (element) {
+          const model = new OutputAreaModel({ trusted: true });
+          const area = new SimplifiedOutputArea({
+            model,
+            rendermime
+          });
+
+          const wrapper = document.createElement('div');
+          wrapper.classList.add('jp-Cell-outputWrapper');
+          const collapser = document.createElement('div');
+          collapser.classList.add(
+            'jp-Collapser',
+            'jp-OutputCollapser',
+            'jp-Cell-outputCollapser'
+          );
+          wrapper.appendChild(collapser);
+          element.lastElementChild?.appendChild(wrapper);
+
+          area.node.classList.add('jp-Cell-outputArea');
+
+          // Why do we need this? Are we missing a CSS class?
+          area.node.style.display = 'flex';
+          area.node.style.flexDirection = 'column';
+
+          Widget.attach(area, wrapper);
+          const skeleton = element
+            .getElementsByClassName('voila-skeleton-container')
+            .item(0);
+          if (skeleton) {
+            element.removeChild(skeleton);
+          }
+          const outputData = output_cell.outputs[0];
+          if (outputData) {
+            console.log(
+              'adding',
+              outputData,
+              'request_kernel_id',
+              request_kernel_id,
+              'kernelId',
+              kernelId
+            );
+            element.lastElementChild?.classList.remove(
+              'jp-mod-noOutputs',
+              'jp-mod-noInput'
+            );
+            model.add(outputData);
+          }
+        }
       }
-      const output = rendermime.createRenderer(mimeType);
-      output.renderModel(model).catch((error) => {
-        // Manually append error message to output
-        const pre = document.createElement('pre');
-        pre.textContent = `Javascript Error: ${error.message}`;
-        output.node.appendChild(pre);
-
-        // Remove mime-type-specific CSS classes
-        pre.className = 'lm-Widget jp-RenderedText';
-        pre.setAttribute('data-mime-type', 'application/vnd.jupyter.stderr');
-      });
-
-      output.addClass('jp-OutputArea-output');
-
-      if (cellOutput.parentElement) {
-        const container = cellOutput.parentElement;
-
-        container.removeChild(cellOutput);
+    };
+    ws.onopen = () => {
+      console.log('opened');
+      ws.send(
+        JSON.stringify({ action: 'execute', payload: { kernel_id: kernelId } })
+      );
+    };
 
-        // Attach output
-        Widget.attach(output, container);
-      }
-    });
     const node = document.getElementById('rendered_cells');
     if (node) {
       const cells = new RenderedCells({ node });
diff --git a/share/jupyter/voila/templates/base/skeleton.macro.html.j2 b/share/jupyter/voila/templates/base/skeleton.macro.html.j2
new file mode 100644
index 000000000..460858a76
--- /dev/null
+++ b/share/jupyter/voila/templates/base/skeleton.macro.html.j2
@@ -0,0 +1,61 @@
+{% macro css() %}
+  <!-- voila skeleton -->
+  <style>
+    .voila-skeleton-container {
+      display: flex;
+      flex-direction: column;
+      justify-content: center;
+      align-items: center;
+    }
+
+    .voila-skeleton-post {
+      width: 220px;
+      height: 80px;
+    }
+    .voila-skeleton-post .voila-skeleton-avatar {
+      float: left;
+      width: 52px;
+      height: 52px;
+      background-color: #ccc;
+      border-radius: 25%;
+      margin: 8px;
+      background-image: linear-gradient(90deg, #ddd 0px, #e8e8e8 40px, #ddd 80px);
+      background-size: 600px;
+      animation: shine-avatar 1.6s infinite linear;
+    }
+    .voila-skeleton-post .voila-skeleton-line {
+      float: left;
+      width: 140px;
+      height: 16px;
+      margin-top: 12px;
+      border-radius: 7px;
+      background-image: linear-gradient(90deg, #ddd 0px, #e8e8e8 40px, #ddd 80px);
+      background-size: 600px;
+      animation: shine-lines 1.6s infinite linear;
+    }
+    .voila-skeleton-post .voila-skeleton-avatar + .voila-skeleton-line {
+      margin-top: 11px;
+      width: 100px;
+    }
+    .voila-skeleton-post .voila-skeleton-line ~ .voila-skeleton-line {
+      background-color: #ddd;
+    }
+
+    @keyframes shine-lines {
+      0% {
+        background-position: -100px;
+      }
+      40%, 100% {
+        background-position: 140px;
+      }
+    }
+    @keyframes shine-avatar {
+      0% {
+        background-position: -32px;
+      }
+      40%, 100% {
+        background-position: 208px;
+      }
+    } 
+  </style>
+{% endmacro %}
diff --git a/share/jupyter/voila/templates/base/spinner.macro.html.j2 b/share/jupyter/voila/templates/base/spinner.macro.html.j2
index 627c8ee14..b84e384d7 100644
--- a/share/jupyter/voila/templates/base/spinner.macro.html.j2
+++ b/share/jupyter/voila/templates/base/spinner.macro.html.j2
@@ -33,7 +33,7 @@
 
     .voila-spinner-color2{
       fill:#f8e14b;
-    }
+    }    
   </style>
 {% endmacro %}
 
diff --git a/share/jupyter/voila/templates/base/voila_setup.macro.html.j2 b/share/jupyter/voila/templates/base/voila_setup.macro.html.j2
index 8da579fab..191a4bc08 100644
--- a/share/jupyter/voila/templates/base/voila_setup.macro.html.j2
+++ b/share/jupyter/voila/templates/base/voila_setup.macro.html.j2
@@ -19,7 +19,7 @@
       spinner.style.display="flex";
     }
     var el = document.getElementById("loading_text");
-    innterText = text ?? `Executing ${cell_index} of ${cell_count}`
+    innterText = text ?? `Reading ${cell_index} of ${cell_count}`
     if(el){
       el.innerHTML = innterText;
     }
diff --git a/share/jupyter/voila/templates/lab/index.html.j2 b/share/jupyter/voila/templates/lab/index.html.j2
index 1e3df3083..ad513f67d 100644
--- a/share/jupyter/voila/templates/lab/index.html.j2
+++ b/share/jupyter/voila/templates/lab/index.html.j2
@@ -1,5 +1,6 @@
 {%- extends 'nbconvert/templates/lab/index.html.j2' -%}
 {% import "spinner.macro.html.j2" as spinner %}
+{% import "skeleton.macro.html.j2" as skeleton %}
 {% import "log.macro.html.j2" as log %}
 {% from 'voila_setup.macro.html.j2' import voila_setup_helper_functions, voila_setup_labextensions with context %}
 
@@ -15,6 +16,7 @@
   {% endif %}
 
   {{ spinner.css() }}
+  {{ skeleton.css() }}
 
   <style>
     /*Hide empty cells*/
@@ -108,6 +110,13 @@
           <script>
             voila_process({{ cellloop.index }}, {{ cell_count }})
           </script>
+          <div class="voila-skeleton-container">
+            <div class="voila-skeleton-post">
+              <div class="voila-skeleton-avatar"></div>
+              <div class="voila-skeleton-line"></div>
+              <div class="voila-skeleton-line"></div>
+            </div>
+          </div>
           {{ super() }}
         </div>
       {%- endblock any_cell -%}
diff --git a/voila/app.py b/voila/app.py
index f83fc7690..71a864b46 100644
--- a/voila/app.py
+++ b/voila/app.py
@@ -20,6 +20,8 @@
 import threading
 import webbrowser
 
+from .execution_request_handler import ExecutionRequestHandler
+
 from .tornado.contentshandler import VoilaContentsHandler
 
 from .voila_identity_provider import VoilaLoginHandler
@@ -715,7 +717,7 @@ def init_handlers(self) -> List:
             ]
         )
         handlers.extend(self.identity_provider.get_handlers())
-        if self.voila_configuration.preheat_kernel:
+        if self.voila_configuration.preheat_kernel or True:
             handlers.append(
                 (
                     url_path_join(
@@ -724,6 +726,14 @@ def init_handlers(self) -> List:
                     RequestInfoSocketHandler,
                 )
             )
+        handlers.append(
+            (
+                url_path_join(
+                    self.server_url, r"/voila/execution/%s" % _kernel_id_regex
+                ),
+                ExecutionRequestHandler,
+            )
+        )
         # Serving JupyterLab extensions
         handlers.append(
             (
diff --git a/voila/execution_request_handler.py b/voila/execution_request_handler.py
new file mode 100644
index 000000000..9bacec16f
--- /dev/null
+++ b/voila/execution_request_handler.py
@@ -0,0 +1,132 @@
+import json
+import logging
+from typing import Awaitable, Dict
+from jupyter_server.base.handlers import JupyterHandler
+from tornado.websocket import WebSocketHandler
+from jupyter_server.base.websocket import WebSocketMixin
+from jupyter_core.utils import ensure_async
+from nbclient.exceptions import CellExecutionError
+from voila.execute import VoilaExecutor, strip_code_cell_warnings
+import nbformat
+import traceback
+import sys
+
+
+class ExecutionRequestHandler(WebSocketMixin, WebSocketHandler, JupyterHandler):
+    _kernels = {}
+    _execution_data = {}
+    _cache = {}
+
+    def initialize(self, **kwargs):
+        super().initialize()
+        print("cccc", self.kernel_manager)
+
+    def open(self, kernel_id: str) -> None:
+        """Create a new websocket connection, this connection is
+        identified by the kernel id.
+
+        Args:
+            kernel_id (str): Kernel id used by the notebook when it opens
+            the websocket connection.
+        """
+        super().open()
+        print("self", self)
+        self._kernel_id = kernel_id
+        ExecutionRequestHandler._kernels[kernel_id] = self
+        self.write_message({"action": "initialized", "payload": {}})
+        if kernel_id in self._cache:
+            self.write_message(self._cache[kernel_id])
+
+    async def on_message(self, message_str: str | bytes) -> Awaitable[None] | None:
+        message = json.loads(message_str)
+        action = message.get("action", None)
+        payload = message.get("payload", {})
+        if action == "execute":
+            request_kernel_id = payload.get("kernel_id")
+            print("RECEIVEDDDDDDDD", request_kernel_id, self._kernel_id)
+
+            kernel_future = self.kernel_manager.get_kernel(self._kernel_id)
+            km = await ensure_async(kernel_future)
+            execution_data = self._execution_data.get(self._kernel_id)
+
+            nb = execution_data["nb"]
+            executor = VoilaExecutor(
+                nb,
+                km=km,
+                config=execution_data["config"],
+                show_tracebacks=execution_data["show_tracebacks"],
+            )
+            executor.kc = await executor.async_start_new_kernel_client()
+            for cell_idx, input_cell in enumerate(nb.cells):
+                try:
+                    output_cell = await executor.execute_cell(
+                        input_cell, None, cell_idx, store_history=False
+                    )
+                except TimeoutError:
+                    output_cell = input_cell
+                    break
+                except CellExecutionError:
+                    self.log.exception(
+                        "Error at server while executing cell: %r", input_cell
+                    )
+                    if executor.should_strip_error():
+                        strip_code_cell_warnings(input_cell)
+                        executor.strip_code_cell_errors(input_cell)
+                    output_cell = input_cell
+                    break
+                except Exception as e:
+                    self.log.exception(
+                        "Error at server while executing cell: %r", input_cell
+                    )
+                    output_cell = nbformat.v4.new_code_cell()
+                    if executor.should_strip_error():
+                        output_cell.outputs = [
+                            {
+                                "output_type": "stream",
+                                "name": "stderr",
+                                "text": "An exception occurred at the server (not the notebook). {}".format(
+                                    executor.cell_error_instruction
+                                ),
+                            }
+                        ]
+                    else:
+                        output_cell.outputs = [
+                            {
+                                "output_type": "error",
+                                "ename": type(e).__name__,
+                                "evalue": str(e),
+                                "traceback": traceback.format_exception(
+                                    *sys.exc_info()
+                                ),
+                            }
+                        ]
+                finally:
+                    await self.write_message(
+                        {
+                            "action": "execution_result",
+                            "payload": {
+                                "request_kernel_id": request_kernel_id,
+                                "output_cell": output_cell,
+                                "cell_index": cell_idx,
+                            },
+                        }
+                    )
+
+    def on_close(self) -> None:
+        for k_id, waiter in ExecutionRequestHandler._kernels.items():
+            if waiter == self:
+                break
+        del ExecutionRequestHandler._kernels[k_id]
+
+    @classmethod
+    def send_updates(cls: "ExecutionRequestHandler", msg: Dict) -> None:
+        kernel_id = msg["kernel_id"]
+        payload = msg["payload"]
+        waiter = cls._kernels.get(kernel_id, None)
+        if waiter is not None:
+            try:
+                waiter.write_message(payload)
+            except Exception:
+                logging.error("Error sending message", exc_info=True)
+        else:
+            cls._cache[kernel_id] = payload
diff --git a/voila/handler.py b/voila/handler.py
index 22a541524..2b6fec472 100644
--- a/voila/handler.py
+++ b/voila/handler.py
@@ -19,6 +19,8 @@
 from tornado.httputil import split_host_and_port
 from traitlets.traitlets import Bool
 
+from voila.execution_request_handler import ExecutionRequestHandler
+
 from .configuration import VoilaConfiguration
 
 from ._version import __version__
@@ -237,6 +239,12 @@ def time_out():
             kernel_future = self.kernel_manager.get_kernel(kernel_id)
             queue = asyncio.Queue()
 
+            ExecutionRequestHandler._execution_data[kernel_id] = {
+                "nb": gen.notebook,
+                "config": self.traitlet_config,
+                "show_tracebacks": self.voila_configuration.show_tracebacks,
+            }
+
             async def put_html():
                 async for html_snippet, _ in gen.generate_content_generator(
                     kernel_id, kernel_future
diff --git a/voila/notebook_renderer.py b/voila/notebook_renderer.py
index 2ba094e59..e40fc37d7 100644
--- a/voila/notebook_renderer.py
+++ b/voila/notebook_renderer.py
@@ -242,6 +242,7 @@ async def _jinja_kernel_start(self, nb, kernel_id, kernel_future):
         return kernel_id
 
     async def _jinja_notebook_execute(self, nb, kernel_id):
+        print('VVVVVVVVVVVVVVVV _jinja_notebook_execute' )
         result = await self.executor.async_execute(cleanup_kc=False)
         # we modify the notebook in place, since the nb variable cannot be
         # reassigned it seems in jinja2 e.g. if we do {% with nb = notebook_execute(nb, kernel_id) %}
@@ -253,52 +254,55 @@ async def _jinja_notebook_execute(self, nb, kernel_id):
 
     async def _jinja_cell_generator(self, nb, kernel_id):
         """Generator that will execute a single notebook cell at a time"""
+        print('VVVVVVVVVVVVVVVV _jinja_cell_generator' )
         nb, _ = ClearOutputPreprocessor().preprocess(
             nb, {"metadata": {"path": self.cwd}}
         )
         for cell_idx, input_cell in enumerate(nb.cells):
-            try:
-                output_cell = await self.executor.execute_cell(
-                    input_cell, None, cell_idx, store_history=False
-                )
-            except TimeoutError:
-                output_cell = input_cell
-                break
-            except CellExecutionError:
-                self.log.exception(
-                    "Error at server while executing cell: %r", input_cell
-                )
-                if self.executor.should_strip_error():
-                    strip_code_cell_warnings(input_cell)
-                    self.executor.strip_code_cell_errors(input_cell)
-                output_cell = input_cell
-                break
-            except Exception as e:
-                self.log.exception(
-                    "Error at server while executing cell: %r", input_cell
-                )
-                output_cell = nbformat.v4.new_code_cell()
-                if self.executor.should_strip_error():
-                    output_cell.outputs = [
-                        {
-                            "output_type": "stream",
-                            "name": "stderr",
-                            "text": "An exception occurred at the server (not the notebook). {}".format(
-                                self.executor.cell_error_instruction
-                            ),
-                        }
-                    ]
-                else:
-                    output_cell.outputs = [
-                        {
-                            "output_type": "error",
-                            "ename": type(e).__name__,
-                            "evalue": str(e),
-                            "traceback": traceback.format_exception(*sys.exc_info()),
-                        }
-                    ]
-            finally:
-                yield output_cell
+            output = input_cell.copy()
+            yield output
+            # try:
+            #     output_cell = await self.executor.execute_cell(
+            #         input_cell, None, cell_idx, store_history=False
+            #     )
+            # except TimeoutError:
+            #     output_cell = input_cell
+            #     break
+            # except CellExecutionError:
+            #     self.log.exception(
+            #         "Error at server while executing cell: %r", input_cell
+            #     )
+            #     if self.executor.should_strip_error():
+            #         strip_code_cell_warnings(input_cell)
+            #         self.executor.strip_code_cell_errors(input_cell)
+            #     output_cell = input_cell
+            #     break
+            # except Exception as e:
+            #     self.log.exception(
+            #         "Error at server while executing cell: %r", input_cell
+            #     )
+            #     output_cell = nbformat.v4.new_code_cell()
+            #     if self.executor.should_strip_error():
+            #         output_cell.outputs = [
+            #             {
+            #                 "output_type": "stream",
+            #                 "name": "stderr",
+            #                 "text": "An exception occurred at the server (not the notebook). {}".format(
+            #                     self.executor.cell_error_instruction
+            #                 ),
+            #             }
+            #         ]
+            #     else:
+            #         output_cell.outputs = [
+            #             {
+            #                 "output_type": "error",
+            #                 "ename": type(e).__name__,
+            #                 "evalue": str(e),
+            #                 "traceback": traceback.format_exception(*sys.exc_info()),
+            #             }
+            #         ]
+            # finally:
+            #     yield output_cell
 
         await self._cleanup_resources()
 
diff --git a/voila/request_info_handler.py b/voila/request_info_handler.py
index 57e8ac610..8e1596b85 100644
--- a/voila/request_info_handler.py
+++ b/voila/request_info_handler.py
@@ -44,7 +44,7 @@ def send_updates(cls: "RequestInfoSocketHandler", msg: Dict) -> None:
         notebook. This method is called in `VoilaHandler` when the request
         info becomes available.
         If this method is called before the opening of websocket connection,
-        `msg` is stored in `_cache0` and the message will be dispatched when
+        `msg` is stored in `_cache` and the message will be dispatched when
         a notebook with corresponding kernel id is connected.
 
         Args:
@@ -59,5 +59,5 @@ def send_updates(cls: "RequestInfoSocketHandler", msg: Dict) -> None:
                 waiter.write_message(payload)
             except Exception:
                 logging.error("Error sending message", exc_info=True)
-
-        cls._cache[kernel_id] = payload
+        else:
+            cls._cache[kernel_id] = payload